strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSStore:
  785    __slots__ = [
  786        'id',
  787        'name',
  788        'region',
  789        'tags',
  790    ]
  791
  792    def __init__(
  793        self,
  794        id=None,
  795        name=None,
  796        region=None,
  797        tags=None,
  798    ):
  799        self.id = id if id is not None else ''
  800        '''
  801         Unique identifier of the SecretStore.
  802        '''
  803        self.name = name if name is not None else ''
  804        '''
  805         Unique human-readable name of the SecretStore.
  806        '''
  807        self.region = region if region is not None else ''
  808        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  809        '''
  810         Tags is a map of key, value pairs.
  811        '''
  812
  813    def __repr__(self):
  814        return '<sdm.AWSStore ' + \
  815            'id: ' + repr(self.id) + ' ' +\
  816            'name: ' + repr(self.name) + ' ' +\
  817            'region: ' + repr(self.region) + ' ' +\
  818            'tags: ' + repr(self.tags) + ' ' +\
  819            '>'
  820
  821    def to_dict(self):
  822        return {
  823            'id': self.id,
  824            'name': self.name,
  825            'region': self.region,
  826            'tags': self.tags,
  827        }
  828
  829    @classmethod
  830    def from_dict(cls, d):
  831        return cls(
  832            id=d.get('id'),
  833            name=d.get('name'),
  834            region=d.get('region'),
  835            tags=d.get('tags'),
  836        )
  837
  838
  839class AccountAttachment:
  840    '''
  841         AccountAttachments assign an account to a role.
  842    '''
  843    __slots__ = [
  844        'account_id',
  845        'id',
  846        'role_id',
  847    ]
  848
  849    def __init__(
  850        self,
  851        account_id=None,
  852        id=None,
  853        role_id=None,
  854    ):
  855        self.account_id = account_id if account_id is not None else ''
  856        '''
  857         The id of the account of this AccountAttachment.
  858        '''
  859        self.id = id if id is not None else ''
  860        '''
  861         Unique identifier of the AccountAttachment.
  862        '''
  863        self.role_id = role_id if role_id is not None else ''
  864        '''
  865         The id of the attached role of this AccountAttachment.
  866        '''
  867
  868    def __repr__(self):
  869        return '<sdm.AccountAttachment ' + \
  870            'account_id: ' + repr(self.account_id) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'role_id: ' + repr(self.role_id) + ' ' +\
  873            '>'
  874
  875    def to_dict(self):
  876        return {
  877            'account_id': self.account_id,
  878            'id': self.id,
  879            'role_id': self.role_id,
  880        }
  881
  882    @classmethod
  883    def from_dict(cls, d):
  884        return cls(
  885            account_id=d.get('account_id'),
  886            id=d.get('id'),
  887            role_id=d.get('role_id'),
  888        )
  889
  890
  891class AccountAttachmentCreateResponse:
  892    '''
  893         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
  894    '''
  895    __slots__ = [
  896        'account_attachment',
  897        'meta',
  898        'rate_limit',
  899    ]
  900
  901    def __init__(
  902        self,
  903        account_attachment=None,
  904        meta=None,
  905        rate_limit=None,
  906    ):
  907        self.account_attachment = account_attachment if account_attachment is not None else None
  908        '''
  909         The created AccountAttachment.
  910        '''
  911        self.meta = meta if meta is not None else None
  912        '''
  913         Reserved for future use.
  914        '''
  915        self.rate_limit = rate_limit if rate_limit is not None else None
  916        '''
  917         Rate limit information.
  918        '''
  919
  920    def __repr__(self):
  921        return '<sdm.AccountAttachmentCreateResponse ' + \
  922            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
  923            'meta: ' + repr(self.meta) + ' ' +\
  924            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  925            '>'
  926
  927    def to_dict(self):
  928        return {
  929            'account_attachment': self.account_attachment,
  930            'meta': self.meta,
  931            'rate_limit': self.rate_limit,
  932        }
  933
  934    @classmethod
  935    def from_dict(cls, d):
  936        return cls(
  937            account_attachment=d.get('account_attachment'),
  938            meta=d.get('meta'),
  939            rate_limit=d.get('rate_limit'),
  940        )
  941
  942
  943class AccountAttachmentDeleteResponse:
  944    '''
  945         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
  946    '''
  947    __slots__ = [
  948        'meta',
  949        'rate_limit',
  950    ]
  951
  952    def __init__(
  953        self,
  954        meta=None,
  955        rate_limit=None,
  956    ):
  957        self.meta = meta if meta is not None else None
  958        '''
  959         Reserved for future use.
  960        '''
  961        self.rate_limit = rate_limit if rate_limit is not None else None
  962        '''
  963         Rate limit information.
  964        '''
  965
  966    def __repr__(self):
  967        return '<sdm.AccountAttachmentDeleteResponse ' + \
  968            'meta: ' + repr(self.meta) + ' ' +\
  969            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  970            '>'
  971
  972    def to_dict(self):
  973        return {
  974            'meta': self.meta,
  975            'rate_limit': self.rate_limit,
  976        }
  977
  978    @classmethod
  979    def from_dict(cls, d):
  980        return cls(
  981            meta=d.get('meta'),
  982            rate_limit=d.get('rate_limit'),
  983        )
  984
  985
  986class AccountAttachmentGetResponse:
  987    '''
  988         AccountAttachmentGetResponse returns a requested AccountAttachment.
  989    '''
  990    __slots__ = [
  991        'account_attachment',
  992        'meta',
  993        'rate_limit',
  994    ]
  995
  996    def __init__(
  997        self,
  998        account_attachment=None,
  999        meta=None,
 1000        rate_limit=None,
 1001    ):
 1002        self.account_attachment = account_attachment if account_attachment is not None else None
 1003        '''
 1004         The requested AccountAttachment.
 1005        '''
 1006        self.meta = meta if meta is not None else None
 1007        '''
 1008         Reserved for future use.
 1009        '''
 1010        self.rate_limit = rate_limit if rate_limit is not None else None
 1011        '''
 1012         Rate limit information.
 1013        '''
 1014
 1015    def __repr__(self):
 1016        return '<sdm.AccountAttachmentGetResponse ' + \
 1017            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1018            'meta: ' + repr(self.meta) + ' ' +\
 1019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1020            '>'
 1021
 1022    def to_dict(self):
 1023        return {
 1024            'account_attachment': self.account_attachment,
 1025            'meta': self.meta,
 1026            'rate_limit': self.rate_limit,
 1027        }
 1028
 1029    @classmethod
 1030    def from_dict(cls, d):
 1031        return cls(
 1032            account_attachment=d.get('account_attachment'),
 1033            meta=d.get('meta'),
 1034            rate_limit=d.get('rate_limit'),
 1035        )
 1036
 1037
 1038class AccountCreateResponse:
 1039    '''
 1040         AccountCreateResponse reports how the Accounts were created in the system.
 1041    '''
 1042    __slots__ = [
 1043        'account',
 1044        'meta',
 1045        'rate_limit',
 1046        'token',
 1047    ]
 1048
 1049    def __init__(
 1050        self,
 1051        account=None,
 1052        meta=None,
 1053        rate_limit=None,
 1054        token=None,
 1055    ):
 1056        self.account = account if account is not None else None
 1057        '''
 1058         The created Account.
 1059        '''
 1060        self.meta = meta if meta is not None else None
 1061        '''
 1062         Reserved for future use.
 1063        '''
 1064        self.rate_limit = rate_limit if rate_limit is not None else None
 1065        '''
 1066         Rate limit information.
 1067        '''
 1068        self.token = token if token is not None else ''
 1069        '''
 1070         The auth token generated for the Account. The Account will use this token to
 1071         authenticate with the strongDM API.
 1072        '''
 1073
 1074    def __repr__(self):
 1075        return '<sdm.AccountCreateResponse ' + \
 1076            'account: ' + repr(self.account) + ' ' +\
 1077            'meta: ' + repr(self.meta) + ' ' +\
 1078            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1079            'token: ' + repr(self.token) + ' ' +\
 1080            '>'
 1081
 1082    def to_dict(self):
 1083        return {
 1084            'account': self.account,
 1085            'meta': self.meta,
 1086            'rate_limit': self.rate_limit,
 1087            'token': self.token,
 1088        }
 1089
 1090    @classmethod
 1091    def from_dict(cls, d):
 1092        return cls(
 1093            account=d.get('account'),
 1094            meta=d.get('meta'),
 1095            rate_limit=d.get('rate_limit'),
 1096            token=d.get('token'),
 1097        )
 1098
 1099
 1100class AccountDeleteResponse:
 1101    '''
 1102         AccountDeleteResponse returns information about a Account that was deleted.
 1103    '''
 1104    __slots__ = [
 1105        'meta',
 1106        'rate_limit',
 1107    ]
 1108
 1109    def __init__(
 1110        self,
 1111        meta=None,
 1112        rate_limit=None,
 1113    ):
 1114        self.meta = meta if meta is not None else None
 1115        '''
 1116         Reserved for future use.
 1117        '''
 1118        self.rate_limit = rate_limit if rate_limit is not None else None
 1119        '''
 1120         Rate limit information.
 1121        '''
 1122
 1123    def __repr__(self):
 1124        return '<sdm.AccountDeleteResponse ' + \
 1125            'meta: ' + repr(self.meta) + ' ' +\
 1126            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1127            '>'
 1128
 1129    def to_dict(self):
 1130        return {
 1131            'meta': self.meta,
 1132            'rate_limit': self.rate_limit,
 1133        }
 1134
 1135    @classmethod
 1136    def from_dict(cls, d):
 1137        return cls(
 1138            meta=d.get('meta'),
 1139            rate_limit=d.get('rate_limit'),
 1140        )
 1141
 1142
 1143class AccountGetResponse:
 1144    '''
 1145         AccountGetResponse returns a requested Account.
 1146    '''
 1147    __slots__ = [
 1148        'account',
 1149        'meta',
 1150        'rate_limit',
 1151    ]
 1152
 1153    def __init__(
 1154        self,
 1155        account=None,
 1156        meta=None,
 1157        rate_limit=None,
 1158    ):
 1159        self.account = account if account is not None else None
 1160        '''
 1161         The requested Account.
 1162        '''
 1163        self.meta = meta if meta is not None else None
 1164        '''
 1165         Reserved for future use.
 1166        '''
 1167        self.rate_limit = rate_limit if rate_limit is not None else None
 1168        '''
 1169         Rate limit information.
 1170        '''
 1171
 1172    def __repr__(self):
 1173        return '<sdm.AccountGetResponse ' + \
 1174            'account: ' + repr(self.account) + ' ' +\
 1175            'meta: ' + repr(self.meta) + ' ' +\
 1176            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1177            '>'
 1178
 1179    def to_dict(self):
 1180        return {
 1181            'account': self.account,
 1182            'meta': self.meta,
 1183            'rate_limit': self.rate_limit,
 1184        }
 1185
 1186    @classmethod
 1187    def from_dict(cls, d):
 1188        return cls(
 1189            account=d.get('account'),
 1190            meta=d.get('meta'),
 1191            rate_limit=d.get('rate_limit'),
 1192        )
 1193
 1194
 1195class AccountGrant:
 1196    '''
 1197         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1198    '''
 1199    __slots__ = [
 1200        'account_id',
 1201        'id',
 1202        'resource_id',
 1203        'start_from',
 1204        'valid_until',
 1205    ]
 1206
 1207    def __init__(
 1208        self,
 1209        account_id=None,
 1210        id=None,
 1211        resource_id=None,
 1212        start_from=None,
 1213        valid_until=None,
 1214    ):
 1215        self.account_id = account_id if account_id is not None else ''
 1216        '''
 1217         The account ID of this AccountGrant.
 1218        '''
 1219        self.id = id if id is not None else ''
 1220        '''
 1221         Unique identifier of the AccountGrant.
 1222        '''
 1223        self.resource_id = resource_id if resource_id is not None else ''
 1224        '''
 1225         The resource ID of this AccountGrant.
 1226        '''
 1227        self.start_from = start_from if start_from is not None else None
 1228        '''
 1229         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1230        '''
 1231        self.valid_until = valid_until if valid_until is not None else None
 1232        '''
 1233         The timestamp when the resource grant will expire.
 1234        '''
 1235
 1236    def __repr__(self):
 1237        return '<sdm.AccountGrant ' + \
 1238            'account_id: ' + repr(self.account_id) + ' ' +\
 1239            'id: ' + repr(self.id) + ' ' +\
 1240            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1241            'start_from: ' + repr(self.start_from) + ' ' +\
 1242            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1243            '>'
 1244
 1245    def to_dict(self):
 1246        return {
 1247            'account_id': self.account_id,
 1248            'id': self.id,
 1249            'resource_id': self.resource_id,
 1250            'start_from': self.start_from,
 1251            'valid_until': self.valid_until,
 1252        }
 1253
 1254    @classmethod
 1255    def from_dict(cls, d):
 1256        return cls(
 1257            account_id=d.get('account_id'),
 1258            id=d.get('id'),
 1259            resource_id=d.get('resource_id'),
 1260            start_from=d.get('start_from'),
 1261            valid_until=d.get('valid_until'),
 1262        )
 1263
 1264
 1265class AccountGrantCreateResponse:
 1266    '''
 1267         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1268    '''
 1269    __slots__ = [
 1270        'account_grant',
 1271        'meta',
 1272        'rate_limit',
 1273    ]
 1274
 1275    def __init__(
 1276        self,
 1277        account_grant=None,
 1278        meta=None,
 1279        rate_limit=None,
 1280    ):
 1281        self.account_grant = account_grant if account_grant is not None else None
 1282        '''
 1283         The created AccountGrant.
 1284        '''
 1285        self.meta = meta if meta is not None else None
 1286        '''
 1287         Reserved for future use.
 1288        '''
 1289        self.rate_limit = rate_limit if rate_limit is not None else None
 1290        '''
 1291         Rate limit information.
 1292        '''
 1293
 1294    def __repr__(self):
 1295        return '<sdm.AccountGrantCreateResponse ' + \
 1296            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1297            'meta: ' + repr(self.meta) + ' ' +\
 1298            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1299            '>'
 1300
 1301    def to_dict(self):
 1302        return {
 1303            'account_grant': self.account_grant,
 1304            'meta': self.meta,
 1305            'rate_limit': self.rate_limit,
 1306        }
 1307
 1308    @classmethod
 1309    def from_dict(cls, d):
 1310        return cls(
 1311            account_grant=d.get('account_grant'),
 1312            meta=d.get('meta'),
 1313            rate_limit=d.get('rate_limit'),
 1314        )
 1315
 1316
 1317class AccountGrantDeleteResponse:
 1318    '''
 1319         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1320    '''
 1321    __slots__ = [
 1322        'meta',
 1323        'rate_limit',
 1324    ]
 1325
 1326    def __init__(
 1327        self,
 1328        meta=None,
 1329        rate_limit=None,
 1330    ):
 1331        self.meta = meta if meta is not None else None
 1332        '''
 1333         Reserved for future use.
 1334        '''
 1335        self.rate_limit = rate_limit if rate_limit is not None else None
 1336        '''
 1337         Rate limit information.
 1338        '''
 1339
 1340    def __repr__(self):
 1341        return '<sdm.AccountGrantDeleteResponse ' + \
 1342            'meta: ' + repr(self.meta) + ' ' +\
 1343            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1344            '>'
 1345
 1346    def to_dict(self):
 1347        return {
 1348            'meta': self.meta,
 1349            'rate_limit': self.rate_limit,
 1350        }
 1351
 1352    @classmethod
 1353    def from_dict(cls, d):
 1354        return cls(
 1355            meta=d.get('meta'),
 1356            rate_limit=d.get('rate_limit'),
 1357        )
 1358
 1359
 1360class AccountGrantGetResponse:
 1361    '''
 1362         AccountGrantGetResponse returns a requested AccountGrant.
 1363    '''
 1364    __slots__ = [
 1365        'account_grant',
 1366        'meta',
 1367        'rate_limit',
 1368    ]
 1369
 1370    def __init__(
 1371        self,
 1372        account_grant=None,
 1373        meta=None,
 1374        rate_limit=None,
 1375    ):
 1376        self.account_grant = account_grant if account_grant is not None else None
 1377        '''
 1378         The requested AccountGrant.
 1379        '''
 1380        self.meta = meta if meta is not None else None
 1381        '''
 1382         Reserved for future use.
 1383        '''
 1384        self.rate_limit = rate_limit if rate_limit is not None else None
 1385        '''
 1386         Rate limit information.
 1387        '''
 1388
 1389    def __repr__(self):
 1390        return '<sdm.AccountGrantGetResponse ' + \
 1391            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1392            'meta: ' + repr(self.meta) + ' ' +\
 1393            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1394            '>'
 1395
 1396    def to_dict(self):
 1397        return {
 1398            'account_grant': self.account_grant,
 1399            'meta': self.meta,
 1400            'rate_limit': self.rate_limit,
 1401        }
 1402
 1403    @classmethod
 1404    def from_dict(cls, d):
 1405        return cls(
 1406            account_grant=d.get('account_grant'),
 1407            meta=d.get('meta'),
 1408            rate_limit=d.get('rate_limit'),
 1409        )
 1410
 1411
 1412class AccountUpdateResponse:
 1413    '''
 1414         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1415     a AccountUpdateRequest.
 1416    '''
 1417    __slots__ = [
 1418        'account',
 1419        'meta',
 1420        'rate_limit',
 1421    ]
 1422
 1423    def __init__(
 1424        self,
 1425        account=None,
 1426        meta=None,
 1427        rate_limit=None,
 1428    ):
 1429        self.account = account if account is not None else None
 1430        '''
 1431         The updated Account.
 1432        '''
 1433        self.meta = meta if meta is not None else None
 1434        '''
 1435         Reserved for future use.
 1436        '''
 1437        self.rate_limit = rate_limit if rate_limit is not None else None
 1438        '''
 1439         Rate limit information.
 1440        '''
 1441
 1442    def __repr__(self):
 1443        return '<sdm.AccountUpdateResponse ' + \
 1444            'account: ' + repr(self.account) + ' ' +\
 1445            'meta: ' + repr(self.meta) + ' ' +\
 1446            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1447            '>'
 1448
 1449    def to_dict(self):
 1450        return {
 1451            'account': self.account,
 1452            'meta': self.meta,
 1453            'rate_limit': self.rate_limit,
 1454        }
 1455
 1456    @classmethod
 1457    def from_dict(cls, d):
 1458        return cls(
 1459            account=d.get('account'),
 1460            meta=d.get('meta'),
 1461            rate_limit=d.get('rate_limit'),
 1462        )
 1463
 1464
 1465class AmazonEKS:
 1466    __slots__ = [
 1467        'access_key',
 1468        'bind_interface',
 1469        'certificate_authority',
 1470        'cluster_name',
 1471        'egress_filter',
 1472        'endpoint',
 1473        'healthcheck_namespace',
 1474        'healthy',
 1475        'id',
 1476        'name',
 1477        'region',
 1478        'remote_identity_group_id',
 1479        'remote_identity_healthcheck_username',
 1480        'role_arn',
 1481        'role_external_id',
 1482        'secret_access_key',
 1483        'secret_store_id',
 1484        'tags',
 1485    ]
 1486
 1487    def __init__(
 1488        self,
 1489        access_key=None,
 1490        bind_interface=None,
 1491        certificate_authority=None,
 1492        cluster_name=None,
 1493        egress_filter=None,
 1494        endpoint=None,
 1495        healthcheck_namespace=None,
 1496        healthy=None,
 1497        id=None,
 1498        name=None,
 1499        region=None,
 1500        remote_identity_group_id=None,
 1501        remote_identity_healthcheck_username=None,
 1502        role_arn=None,
 1503        role_external_id=None,
 1504        secret_access_key=None,
 1505        secret_store_id=None,
 1506        tags=None,
 1507    ):
 1508        self.access_key = access_key if access_key is not None else ''
 1509        self.bind_interface = bind_interface if bind_interface is not None else ''
 1510        '''
 1511         Bind interface
 1512        '''
 1513        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1514        self.cluster_name = cluster_name if cluster_name is not None else ''
 1515        self.egress_filter = egress_filter if egress_filter is not None else ''
 1516        '''
 1517         A filter applied to the routing logic to pin datasource to nodes.
 1518        '''
 1519        self.endpoint = endpoint if endpoint is not None else ''
 1520        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1521        '''
 1522         The path used to check the health of your connection.  Defaults to `default`.
 1523        '''
 1524        self.healthy = healthy if healthy is not None else False
 1525        '''
 1526         True if the datasource is reachable and the credentials are valid.
 1527        '''
 1528        self.id = id if id is not None else ''
 1529        '''
 1530         Unique identifier of the Resource.
 1531        '''
 1532        self.name = name if name is not None else ''
 1533        '''
 1534         Unique human-readable name of the Resource.
 1535        '''
 1536        self.region = region if region is not None else ''
 1537        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1538        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1539        self.role_arn = role_arn if role_arn is not None else ''
 1540        self.role_external_id = role_external_id if role_external_id is not None else ''
 1541        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1542        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1543        '''
 1544         ID of the secret store containing credentials for this resource, if any.
 1545        '''
 1546        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1547        '''
 1548         Tags is a map of key, value pairs.
 1549        '''
 1550
 1551    def __repr__(self):
 1552        return '<sdm.AmazonEKS ' + \
 1553            'access_key: ' + repr(self.access_key) + ' ' +\
 1554            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1555            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1556            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1557            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1558            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1559            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1560            'healthy: ' + repr(self.healthy) + ' ' +\
 1561            'id: ' + repr(self.id) + ' ' +\
 1562            'name: ' + repr(self.name) + ' ' +\
 1563            'region: ' + repr(self.region) + ' ' +\
 1564            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1565            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1566            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1567            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1568            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1569            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1570            'tags: ' + repr(self.tags) + ' ' +\
 1571            '>'
 1572
 1573    def to_dict(self):
 1574        return {
 1575            'access_key': self.access_key,
 1576            'bind_interface': self.bind_interface,
 1577            'certificate_authority': self.certificate_authority,
 1578            'cluster_name': self.cluster_name,
 1579            'egress_filter': self.egress_filter,
 1580            'endpoint': self.endpoint,
 1581            'healthcheck_namespace': self.healthcheck_namespace,
 1582            'healthy': self.healthy,
 1583            'id': self.id,
 1584            'name': self.name,
 1585            'region': self.region,
 1586            'remote_identity_group_id': self.remote_identity_group_id,
 1587            'remote_identity_healthcheck_username':
 1588            self.remote_identity_healthcheck_username,
 1589            'role_arn': self.role_arn,
 1590            'role_external_id': self.role_external_id,
 1591            'secret_access_key': self.secret_access_key,
 1592            'secret_store_id': self.secret_store_id,
 1593            'tags': self.tags,
 1594        }
 1595
 1596    @classmethod
 1597    def from_dict(cls, d):
 1598        return cls(
 1599            access_key=d.get('access_key'),
 1600            bind_interface=d.get('bind_interface'),
 1601            certificate_authority=d.get('certificate_authority'),
 1602            cluster_name=d.get('cluster_name'),
 1603            egress_filter=d.get('egress_filter'),
 1604            endpoint=d.get('endpoint'),
 1605            healthcheck_namespace=d.get('healthcheck_namespace'),
 1606            healthy=d.get('healthy'),
 1607            id=d.get('id'),
 1608            name=d.get('name'),
 1609            region=d.get('region'),
 1610            remote_identity_group_id=d.get('remote_identity_group_id'),
 1611            remote_identity_healthcheck_username=d.get(
 1612                'remote_identity_healthcheck_username'),
 1613            role_arn=d.get('role_arn'),
 1614            role_external_id=d.get('role_external_id'),
 1615            secret_access_key=d.get('secret_access_key'),
 1616            secret_store_id=d.get('secret_store_id'),
 1617            tags=d.get('tags'),
 1618        )
 1619
 1620
 1621class AmazonEKSUserImpersonation:
 1622    __slots__ = [
 1623        'access_key',
 1624        'bind_interface',
 1625        'certificate_authority',
 1626        'cluster_name',
 1627        'egress_filter',
 1628        'endpoint',
 1629        'healthcheck_namespace',
 1630        'healthy',
 1631        'id',
 1632        'name',
 1633        'region',
 1634        'role_arn',
 1635        'role_external_id',
 1636        'secret_access_key',
 1637        'secret_store_id',
 1638        'tags',
 1639    ]
 1640
 1641    def __init__(
 1642        self,
 1643        access_key=None,
 1644        bind_interface=None,
 1645        certificate_authority=None,
 1646        cluster_name=None,
 1647        egress_filter=None,
 1648        endpoint=None,
 1649        healthcheck_namespace=None,
 1650        healthy=None,
 1651        id=None,
 1652        name=None,
 1653        region=None,
 1654        role_arn=None,
 1655        role_external_id=None,
 1656        secret_access_key=None,
 1657        secret_store_id=None,
 1658        tags=None,
 1659    ):
 1660        self.access_key = access_key if access_key is not None else ''
 1661        self.bind_interface = bind_interface if bind_interface is not None else ''
 1662        '''
 1663         Bind interface
 1664        '''
 1665        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1666        self.cluster_name = cluster_name if cluster_name is not None else ''
 1667        self.egress_filter = egress_filter if egress_filter is not None else ''
 1668        '''
 1669         A filter applied to the routing logic to pin datasource to nodes.
 1670        '''
 1671        self.endpoint = endpoint if endpoint is not None else ''
 1672        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1673        '''
 1674         The path used to check the health of your connection.  Defaults to `default`.
 1675        '''
 1676        self.healthy = healthy if healthy is not None else False
 1677        '''
 1678         True if the datasource is reachable and the credentials are valid.
 1679        '''
 1680        self.id = id if id is not None else ''
 1681        '''
 1682         Unique identifier of the Resource.
 1683        '''
 1684        self.name = name if name is not None else ''
 1685        '''
 1686         Unique human-readable name of the Resource.
 1687        '''
 1688        self.region = region if region is not None else ''
 1689        self.role_arn = role_arn if role_arn is not None else ''
 1690        self.role_external_id = role_external_id if role_external_id is not None else ''
 1691        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1693        '''
 1694         ID of the secret store containing credentials for this resource, if any.
 1695        '''
 1696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1697        '''
 1698         Tags is a map of key, value pairs.
 1699        '''
 1700
 1701    def __repr__(self):
 1702        return '<sdm.AmazonEKSUserImpersonation ' + \
 1703            'access_key: ' + repr(self.access_key) + ' ' +\
 1704            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1705            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1706            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1707            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1708            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1709            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1710            'healthy: ' + repr(self.healthy) + ' ' +\
 1711            'id: ' + repr(self.id) + ' ' +\
 1712            'name: ' + repr(self.name) + ' ' +\
 1713            'region: ' + repr(self.region) + ' ' +\
 1714            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1715            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1716            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1717            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1718            'tags: ' + repr(self.tags) + ' ' +\
 1719            '>'
 1720
 1721    def to_dict(self):
 1722        return {
 1723            'access_key': self.access_key,
 1724            'bind_interface': self.bind_interface,
 1725            'certificate_authority': self.certificate_authority,
 1726            'cluster_name': self.cluster_name,
 1727            'egress_filter': self.egress_filter,
 1728            'endpoint': self.endpoint,
 1729            'healthcheck_namespace': self.healthcheck_namespace,
 1730            'healthy': self.healthy,
 1731            'id': self.id,
 1732            'name': self.name,
 1733            'region': self.region,
 1734            'role_arn': self.role_arn,
 1735            'role_external_id': self.role_external_id,
 1736            'secret_access_key': self.secret_access_key,
 1737            'secret_store_id': self.secret_store_id,
 1738            'tags': self.tags,
 1739        }
 1740
 1741    @classmethod
 1742    def from_dict(cls, d):
 1743        return cls(
 1744            access_key=d.get('access_key'),
 1745            bind_interface=d.get('bind_interface'),
 1746            certificate_authority=d.get('certificate_authority'),
 1747            cluster_name=d.get('cluster_name'),
 1748            egress_filter=d.get('egress_filter'),
 1749            endpoint=d.get('endpoint'),
 1750            healthcheck_namespace=d.get('healthcheck_namespace'),
 1751            healthy=d.get('healthy'),
 1752            id=d.get('id'),
 1753            name=d.get('name'),
 1754            region=d.get('region'),
 1755            role_arn=d.get('role_arn'),
 1756            role_external_id=d.get('role_external_id'),
 1757            secret_access_key=d.get('secret_access_key'),
 1758            secret_store_id=d.get('secret_store_id'),
 1759            tags=d.get('tags'),
 1760        )
 1761
 1762
 1763class AmazonES:
 1764    __slots__ = [
 1765        'access_key',
 1766        'bind_interface',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthy',
 1770        'id',
 1771        'name',
 1772        'port_override',
 1773        'region',
 1774        'role_arn',
 1775        'role_external_id',
 1776        'secret_access_key',
 1777        'secret_store_id',
 1778        'tags',
 1779    ]
 1780
 1781    def __init__(
 1782        self,
 1783        access_key=None,
 1784        bind_interface=None,
 1785        egress_filter=None,
 1786        endpoint=None,
 1787        healthy=None,
 1788        id=None,
 1789        name=None,
 1790        port_override=None,
 1791        region=None,
 1792        role_arn=None,
 1793        role_external_id=None,
 1794        secret_access_key=None,
 1795        secret_store_id=None,
 1796        tags=None,
 1797    ):
 1798        self.access_key = access_key if access_key is not None else ''
 1799        self.bind_interface = bind_interface if bind_interface is not None else ''
 1800        '''
 1801         Bind interface
 1802        '''
 1803        self.egress_filter = egress_filter if egress_filter is not None else ''
 1804        '''
 1805         A filter applied to the routing logic to pin datasource to nodes.
 1806        '''
 1807        self.endpoint = endpoint if endpoint is not None else ''
 1808        self.healthy = healthy if healthy is not None else False
 1809        '''
 1810         True if the datasource is reachable and the credentials are valid.
 1811        '''
 1812        self.id = id if id is not None else ''
 1813        '''
 1814         Unique identifier of the Resource.
 1815        '''
 1816        self.name = name if name is not None else ''
 1817        '''
 1818         Unique human-readable name of the Resource.
 1819        '''
 1820        self.port_override = port_override if port_override is not None else 0
 1821        self.region = region if region is not None else ''
 1822        self.role_arn = role_arn if role_arn is not None else ''
 1823        self.role_external_id = role_external_id if role_external_id is not None else ''
 1824        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1825        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1826        '''
 1827         ID of the secret store containing credentials for this resource, if any.
 1828        '''
 1829        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1830        '''
 1831         Tags is a map of key, value pairs.
 1832        '''
 1833
 1834    def __repr__(self):
 1835        return '<sdm.AmazonES ' + \
 1836            'access_key: ' + repr(self.access_key) + ' ' +\
 1837            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1838            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1839            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1840            'healthy: ' + repr(self.healthy) + ' ' +\
 1841            'id: ' + repr(self.id) + ' ' +\
 1842            'name: ' + repr(self.name) + ' ' +\
 1843            'port_override: ' + repr(self.port_override) + ' ' +\
 1844            'region: ' + repr(self.region) + ' ' +\
 1845            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1846            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1847            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1848            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1849            'tags: ' + repr(self.tags) + ' ' +\
 1850            '>'
 1851
 1852    def to_dict(self):
 1853        return {
 1854            'access_key': self.access_key,
 1855            'bind_interface': self.bind_interface,
 1856            'egress_filter': self.egress_filter,
 1857            'endpoint': self.endpoint,
 1858            'healthy': self.healthy,
 1859            'id': self.id,
 1860            'name': self.name,
 1861            'port_override': self.port_override,
 1862            'region': self.region,
 1863            'role_arn': self.role_arn,
 1864            'role_external_id': self.role_external_id,
 1865            'secret_access_key': self.secret_access_key,
 1866            'secret_store_id': self.secret_store_id,
 1867            'tags': self.tags,
 1868        }
 1869
 1870    @classmethod
 1871    def from_dict(cls, d):
 1872        return cls(
 1873            access_key=d.get('access_key'),
 1874            bind_interface=d.get('bind_interface'),
 1875            egress_filter=d.get('egress_filter'),
 1876            endpoint=d.get('endpoint'),
 1877            healthy=d.get('healthy'),
 1878            id=d.get('id'),
 1879            name=d.get('name'),
 1880            port_override=d.get('port_override'),
 1881            region=d.get('region'),
 1882            role_arn=d.get('role_arn'),
 1883            role_external_id=d.get('role_external_id'),
 1884            secret_access_key=d.get('secret_access_key'),
 1885            secret_store_id=d.get('secret_store_id'),
 1886            tags=d.get('tags'),
 1887        )
 1888
 1889
 1890class AmazonMQAMQP091:
 1891    __slots__ = [
 1892        'bind_interface',
 1893        'egress_filter',
 1894        'healthy',
 1895        'hostname',
 1896        'id',
 1897        'name',
 1898        'password',
 1899        'port',
 1900        'port_override',
 1901        'secret_store_id',
 1902        'tags',
 1903        'tls_required',
 1904        'username',
 1905    ]
 1906
 1907    def __init__(
 1908        self,
 1909        bind_interface=None,
 1910        egress_filter=None,
 1911        healthy=None,
 1912        hostname=None,
 1913        id=None,
 1914        name=None,
 1915        password=None,
 1916        port=None,
 1917        port_override=None,
 1918        secret_store_id=None,
 1919        tags=None,
 1920        tls_required=None,
 1921        username=None,
 1922    ):
 1923        self.bind_interface = bind_interface if bind_interface is not None else ''
 1924        '''
 1925         Bind interface
 1926        '''
 1927        self.egress_filter = egress_filter if egress_filter is not None else ''
 1928        '''
 1929         A filter applied to the routing logic to pin datasource to nodes.
 1930        '''
 1931        self.healthy = healthy if healthy is not None else False
 1932        '''
 1933         True if the datasource is reachable and the credentials are valid.
 1934        '''
 1935        self.hostname = hostname if hostname is not None else ''
 1936        self.id = id if id is not None else ''
 1937        '''
 1938         Unique identifier of the Resource.
 1939        '''
 1940        self.name = name if name is not None else ''
 1941        '''
 1942         Unique human-readable name of the Resource.
 1943        '''
 1944        self.password = password if password is not None else ''
 1945        self.port = port if port is not None else 0
 1946        self.port_override = port_override if port_override is not None else 0
 1947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1948        '''
 1949         ID of the secret store containing credentials for this resource, if any.
 1950        '''
 1951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1952        '''
 1953         Tags is a map of key, value pairs.
 1954        '''
 1955        self.tls_required = tls_required if tls_required is not None else False
 1956        self.username = username if username is not None else ''
 1957
 1958    def __repr__(self):
 1959        return '<sdm.AmazonMQAMQP091 ' + \
 1960            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1961            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1962            'healthy: ' + repr(self.healthy) + ' ' +\
 1963            'hostname: ' + repr(self.hostname) + ' ' +\
 1964            'id: ' + repr(self.id) + ' ' +\
 1965            'name: ' + repr(self.name) + ' ' +\
 1966            'password: ' + repr(self.password) + ' ' +\
 1967            'port: ' + repr(self.port) + ' ' +\
 1968            'port_override: ' + repr(self.port_override) + ' ' +\
 1969            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1970            'tags: ' + repr(self.tags) + ' ' +\
 1971            'tls_required: ' + repr(self.tls_required) + ' ' +\
 1972            'username: ' + repr(self.username) + ' ' +\
 1973            '>'
 1974
 1975    def to_dict(self):
 1976        return {
 1977            'bind_interface': self.bind_interface,
 1978            'egress_filter': self.egress_filter,
 1979            'healthy': self.healthy,
 1980            'hostname': self.hostname,
 1981            'id': self.id,
 1982            'name': self.name,
 1983            'password': self.password,
 1984            'port': self.port,
 1985            'port_override': self.port_override,
 1986            'secret_store_id': self.secret_store_id,
 1987            'tags': self.tags,
 1988            'tls_required': self.tls_required,
 1989            'username': self.username,
 1990        }
 1991
 1992    @classmethod
 1993    def from_dict(cls, d):
 1994        return cls(
 1995            bind_interface=d.get('bind_interface'),
 1996            egress_filter=d.get('egress_filter'),
 1997            healthy=d.get('healthy'),
 1998            hostname=d.get('hostname'),
 1999            id=d.get('id'),
 2000            name=d.get('name'),
 2001            password=d.get('password'),
 2002            port=d.get('port'),
 2003            port_override=d.get('port_override'),
 2004            secret_store_id=d.get('secret_store_id'),
 2005            tags=d.get('tags'),
 2006            tls_required=d.get('tls_required'),
 2007            username=d.get('username'),
 2008        )
 2009
 2010
 2011class Athena:
 2012    __slots__ = [
 2013        'access_key',
 2014        'bind_interface',
 2015        'egress_filter',
 2016        'healthy',
 2017        'id',
 2018        'name',
 2019        'output',
 2020        'port_override',
 2021        'region',
 2022        'role_arn',
 2023        'role_external_id',
 2024        'secret_access_key',
 2025        'secret_store_id',
 2026        'tags',
 2027    ]
 2028
 2029    def __init__(
 2030        self,
 2031        access_key=None,
 2032        bind_interface=None,
 2033        egress_filter=None,
 2034        healthy=None,
 2035        id=None,
 2036        name=None,
 2037        output=None,
 2038        port_override=None,
 2039        region=None,
 2040        role_arn=None,
 2041        role_external_id=None,
 2042        secret_access_key=None,
 2043        secret_store_id=None,
 2044        tags=None,
 2045    ):
 2046        self.access_key = access_key if access_key is not None else ''
 2047        self.bind_interface = bind_interface if bind_interface is not None else ''
 2048        '''
 2049         Bind interface
 2050        '''
 2051        self.egress_filter = egress_filter if egress_filter is not None else ''
 2052        '''
 2053         A filter applied to the routing logic to pin datasource to nodes.
 2054        '''
 2055        self.healthy = healthy if healthy is not None else False
 2056        '''
 2057         True if the datasource is reachable and the credentials are valid.
 2058        '''
 2059        self.id = id if id is not None else ''
 2060        '''
 2061         Unique identifier of the Resource.
 2062        '''
 2063        self.name = name if name is not None else ''
 2064        '''
 2065         Unique human-readable name of the Resource.
 2066        '''
 2067        self.output = output if output is not None else ''
 2068        self.port_override = port_override if port_override is not None else 0
 2069        self.region = region if region is not None else ''
 2070        self.role_arn = role_arn if role_arn is not None else ''
 2071        self.role_external_id = role_external_id if role_external_id is not None else ''
 2072        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2073        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2074        '''
 2075         ID of the secret store containing credentials for this resource, if any.
 2076        '''
 2077        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2078        '''
 2079         Tags is a map of key, value pairs.
 2080        '''
 2081
 2082    def __repr__(self):
 2083        return '<sdm.Athena ' + \
 2084            'access_key: ' + repr(self.access_key) + ' ' +\
 2085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2087            'healthy: ' + repr(self.healthy) + ' ' +\
 2088            'id: ' + repr(self.id) + ' ' +\
 2089            'name: ' + repr(self.name) + ' ' +\
 2090            'output: ' + repr(self.output) + ' ' +\
 2091            'port_override: ' + repr(self.port_override) + ' ' +\
 2092            'region: ' + repr(self.region) + ' ' +\
 2093            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2094            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2095            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2096            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2097            'tags: ' + repr(self.tags) + ' ' +\
 2098            '>'
 2099
 2100    def to_dict(self):
 2101        return {
 2102            'access_key': self.access_key,
 2103            'bind_interface': self.bind_interface,
 2104            'egress_filter': self.egress_filter,
 2105            'healthy': self.healthy,
 2106            'id': self.id,
 2107            'name': self.name,
 2108            'output': self.output,
 2109            'port_override': self.port_override,
 2110            'region': self.region,
 2111            'role_arn': self.role_arn,
 2112            'role_external_id': self.role_external_id,
 2113            'secret_access_key': self.secret_access_key,
 2114            'secret_store_id': self.secret_store_id,
 2115            'tags': self.tags,
 2116        }
 2117
 2118    @classmethod
 2119    def from_dict(cls, d):
 2120        return cls(
 2121            access_key=d.get('access_key'),
 2122            bind_interface=d.get('bind_interface'),
 2123            egress_filter=d.get('egress_filter'),
 2124            healthy=d.get('healthy'),
 2125            id=d.get('id'),
 2126            name=d.get('name'),
 2127            output=d.get('output'),
 2128            port_override=d.get('port_override'),
 2129            region=d.get('region'),
 2130            role_arn=d.get('role_arn'),
 2131            role_external_id=d.get('role_external_id'),
 2132            secret_access_key=d.get('secret_access_key'),
 2133            secret_store_id=d.get('secret_store_id'),
 2134            tags=d.get('tags'),
 2135        )
 2136
 2137
 2138class AuroraMysql:
 2139    __slots__ = [
 2140        'bind_interface',
 2141        'database',
 2142        'egress_filter',
 2143        'healthy',
 2144        'hostname',
 2145        'id',
 2146        'name',
 2147        'password',
 2148        'port',
 2149        'port_override',
 2150        'secret_store_id',
 2151        'tags',
 2152        'username',
 2153    ]
 2154
 2155    def __init__(
 2156        self,
 2157        bind_interface=None,
 2158        database=None,
 2159        egress_filter=None,
 2160        healthy=None,
 2161        hostname=None,
 2162        id=None,
 2163        name=None,
 2164        password=None,
 2165        port=None,
 2166        port_override=None,
 2167        secret_store_id=None,
 2168        tags=None,
 2169        username=None,
 2170    ):
 2171        self.bind_interface = bind_interface if bind_interface is not None else ''
 2172        '''
 2173         Bind interface
 2174        '''
 2175        self.database = database if database is not None else ''
 2176        self.egress_filter = egress_filter if egress_filter is not None else ''
 2177        '''
 2178         A filter applied to the routing logic to pin datasource to nodes.
 2179        '''
 2180        self.healthy = healthy if healthy is not None else False
 2181        '''
 2182         True if the datasource is reachable and the credentials are valid.
 2183        '''
 2184        self.hostname = hostname if hostname is not None else ''
 2185        self.id = id if id is not None else ''
 2186        '''
 2187         Unique identifier of the Resource.
 2188        '''
 2189        self.name = name if name is not None else ''
 2190        '''
 2191         Unique human-readable name of the Resource.
 2192        '''
 2193        self.password = password if password is not None else ''
 2194        self.port = port if port is not None else 0
 2195        self.port_override = port_override if port_override is not None else 0
 2196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2197        '''
 2198         ID of the secret store containing credentials for this resource, if any.
 2199        '''
 2200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2201        '''
 2202         Tags is a map of key, value pairs.
 2203        '''
 2204        self.username = username if username is not None else ''
 2205
 2206    def __repr__(self):
 2207        return '<sdm.AuroraMysql ' + \
 2208            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2209            'database: ' + repr(self.database) + ' ' +\
 2210            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2211            'healthy: ' + repr(self.healthy) + ' ' +\
 2212            'hostname: ' + repr(self.hostname) + ' ' +\
 2213            'id: ' + repr(self.id) + ' ' +\
 2214            'name: ' + repr(self.name) + ' ' +\
 2215            'password: ' + repr(self.password) + ' ' +\
 2216            'port: ' + repr(self.port) + ' ' +\
 2217            'port_override: ' + repr(self.port_override) + ' ' +\
 2218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2219            'tags: ' + repr(self.tags) + ' ' +\
 2220            'username: ' + repr(self.username) + ' ' +\
 2221            '>'
 2222
 2223    def to_dict(self):
 2224        return {
 2225            'bind_interface': self.bind_interface,
 2226            'database': self.database,
 2227            'egress_filter': self.egress_filter,
 2228            'healthy': self.healthy,
 2229            'hostname': self.hostname,
 2230            'id': self.id,
 2231            'name': self.name,
 2232            'password': self.password,
 2233            'port': self.port,
 2234            'port_override': self.port_override,
 2235            'secret_store_id': self.secret_store_id,
 2236            'tags': self.tags,
 2237            'username': self.username,
 2238        }
 2239
 2240    @classmethod
 2241    def from_dict(cls, d):
 2242        return cls(
 2243            bind_interface=d.get('bind_interface'),
 2244            database=d.get('database'),
 2245            egress_filter=d.get('egress_filter'),
 2246            healthy=d.get('healthy'),
 2247            hostname=d.get('hostname'),
 2248            id=d.get('id'),
 2249            name=d.get('name'),
 2250            password=d.get('password'),
 2251            port=d.get('port'),
 2252            port_override=d.get('port_override'),
 2253            secret_store_id=d.get('secret_store_id'),
 2254            tags=d.get('tags'),
 2255            username=d.get('username'),
 2256        )
 2257
 2258
 2259class AuroraPostgres:
 2260    __slots__ = [
 2261        'bind_interface',
 2262        'database',
 2263        'egress_filter',
 2264        'healthy',
 2265        'hostname',
 2266        'id',
 2267        'name',
 2268        'override_database',
 2269        'password',
 2270        'port',
 2271        'port_override',
 2272        'secret_store_id',
 2273        'tags',
 2274        'username',
 2275    ]
 2276
 2277    def __init__(
 2278        self,
 2279        bind_interface=None,
 2280        database=None,
 2281        egress_filter=None,
 2282        healthy=None,
 2283        hostname=None,
 2284        id=None,
 2285        name=None,
 2286        override_database=None,
 2287        password=None,
 2288        port=None,
 2289        port_override=None,
 2290        secret_store_id=None,
 2291        tags=None,
 2292        username=None,
 2293    ):
 2294        self.bind_interface = bind_interface if bind_interface is not None else ''
 2295        '''
 2296         Bind interface
 2297        '''
 2298        self.database = database if database is not None else ''
 2299        self.egress_filter = egress_filter if egress_filter is not None else ''
 2300        '''
 2301         A filter applied to the routing logic to pin datasource to nodes.
 2302        '''
 2303        self.healthy = healthy if healthy is not None else False
 2304        '''
 2305         True if the datasource is reachable and the credentials are valid.
 2306        '''
 2307        self.hostname = hostname if hostname is not None else ''
 2308        self.id = id if id is not None else ''
 2309        '''
 2310         Unique identifier of the Resource.
 2311        '''
 2312        self.name = name if name is not None else ''
 2313        '''
 2314         Unique human-readable name of the Resource.
 2315        '''
 2316        self.override_database = override_database if override_database is not None else False
 2317        self.password = password if password is not None else ''
 2318        self.port = port if port is not None else 0
 2319        self.port_override = port_override if port_override is not None else 0
 2320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2321        '''
 2322         ID of the secret store containing credentials for this resource, if any.
 2323        '''
 2324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2325        '''
 2326         Tags is a map of key, value pairs.
 2327        '''
 2328        self.username = username if username is not None else ''
 2329
 2330    def __repr__(self):
 2331        return '<sdm.AuroraPostgres ' + \
 2332            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2333            'database: ' + repr(self.database) + ' ' +\
 2334            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2335            'healthy: ' + repr(self.healthy) + ' ' +\
 2336            'hostname: ' + repr(self.hostname) + ' ' +\
 2337            'id: ' + repr(self.id) + ' ' +\
 2338            'name: ' + repr(self.name) + ' ' +\
 2339            'override_database: ' + repr(self.override_database) + ' ' +\
 2340            'password: ' + repr(self.password) + ' ' +\
 2341            'port: ' + repr(self.port) + ' ' +\
 2342            'port_override: ' + repr(self.port_override) + ' ' +\
 2343            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2344            'tags: ' + repr(self.tags) + ' ' +\
 2345            'username: ' + repr(self.username) + ' ' +\
 2346            '>'
 2347
 2348    def to_dict(self):
 2349        return {
 2350            'bind_interface': self.bind_interface,
 2351            'database': self.database,
 2352            'egress_filter': self.egress_filter,
 2353            'healthy': self.healthy,
 2354            'hostname': self.hostname,
 2355            'id': self.id,
 2356            'name': self.name,
 2357            'override_database': self.override_database,
 2358            'password': self.password,
 2359            'port': self.port,
 2360            'port_override': self.port_override,
 2361            'secret_store_id': self.secret_store_id,
 2362            'tags': self.tags,
 2363            'username': self.username,
 2364        }
 2365
 2366    @classmethod
 2367    def from_dict(cls, d):
 2368        return cls(
 2369            bind_interface=d.get('bind_interface'),
 2370            database=d.get('database'),
 2371            egress_filter=d.get('egress_filter'),
 2372            healthy=d.get('healthy'),
 2373            hostname=d.get('hostname'),
 2374            id=d.get('id'),
 2375            name=d.get('name'),
 2376            override_database=d.get('override_database'),
 2377            password=d.get('password'),
 2378            port=d.get('port'),
 2379            port_override=d.get('port_override'),
 2380            secret_store_id=d.get('secret_store_id'),
 2381            tags=d.get('tags'),
 2382            username=d.get('username'),
 2383        )
 2384
 2385
 2386class Azure:
 2387    __slots__ = [
 2388        'app_id',
 2389        'bind_interface',
 2390        'egress_filter',
 2391        'healthy',
 2392        'id',
 2393        'name',
 2394        'password',
 2395        'secret_store_id',
 2396        'tags',
 2397        'tenant_id',
 2398    ]
 2399
 2400    def __init__(
 2401        self,
 2402        app_id=None,
 2403        bind_interface=None,
 2404        egress_filter=None,
 2405        healthy=None,
 2406        id=None,
 2407        name=None,
 2408        password=None,
 2409        secret_store_id=None,
 2410        tags=None,
 2411        tenant_id=None,
 2412    ):
 2413        self.app_id = app_id if app_id is not None else ''
 2414        self.bind_interface = bind_interface if bind_interface is not None else ''
 2415        '''
 2416         Bind interface
 2417        '''
 2418        self.egress_filter = egress_filter if egress_filter is not None else ''
 2419        '''
 2420         A filter applied to the routing logic to pin datasource to nodes.
 2421        '''
 2422        self.healthy = healthy if healthy is not None else False
 2423        '''
 2424         True if the datasource is reachable and the credentials are valid.
 2425        '''
 2426        self.id = id if id is not None else ''
 2427        '''
 2428         Unique identifier of the Resource.
 2429        '''
 2430        self.name = name if name is not None else ''
 2431        '''
 2432         Unique human-readable name of the Resource.
 2433        '''
 2434        self.password = password if password is not None else ''
 2435        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2436        '''
 2437         ID of the secret store containing credentials for this resource, if any.
 2438        '''
 2439        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2440        '''
 2441         Tags is a map of key, value pairs.
 2442        '''
 2443        self.tenant_id = tenant_id if tenant_id is not None else ''
 2444
 2445    def __repr__(self):
 2446        return '<sdm.Azure ' + \
 2447            'app_id: ' + repr(self.app_id) + ' ' +\
 2448            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2449            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2450            'healthy: ' + repr(self.healthy) + ' ' +\
 2451            'id: ' + repr(self.id) + ' ' +\
 2452            'name: ' + repr(self.name) + ' ' +\
 2453            'password: ' + repr(self.password) + ' ' +\
 2454            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2455            'tags: ' + repr(self.tags) + ' ' +\
 2456            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2457            '>'
 2458
 2459    def to_dict(self):
 2460        return {
 2461            'app_id': self.app_id,
 2462            'bind_interface': self.bind_interface,
 2463            'egress_filter': self.egress_filter,
 2464            'healthy': self.healthy,
 2465            'id': self.id,
 2466            'name': self.name,
 2467            'password': self.password,
 2468            'secret_store_id': self.secret_store_id,
 2469            'tags': self.tags,
 2470            'tenant_id': self.tenant_id,
 2471        }
 2472
 2473    @classmethod
 2474    def from_dict(cls, d):
 2475        return cls(
 2476            app_id=d.get('app_id'),
 2477            bind_interface=d.get('bind_interface'),
 2478            egress_filter=d.get('egress_filter'),
 2479            healthy=d.get('healthy'),
 2480            id=d.get('id'),
 2481            name=d.get('name'),
 2482            password=d.get('password'),
 2483            secret_store_id=d.get('secret_store_id'),
 2484            tags=d.get('tags'),
 2485            tenant_id=d.get('tenant_id'),
 2486        )
 2487
 2488
 2489class AzureCertificate:
 2490    __slots__ = [
 2491        'app_id',
 2492        'bind_interface',
 2493        'client_certificate',
 2494        'egress_filter',
 2495        'healthy',
 2496        'id',
 2497        'name',
 2498        'secret_store_id',
 2499        'tags',
 2500        'tenant_id',
 2501    ]
 2502
 2503    def __init__(
 2504        self,
 2505        app_id=None,
 2506        bind_interface=None,
 2507        client_certificate=None,
 2508        egress_filter=None,
 2509        healthy=None,
 2510        id=None,
 2511        name=None,
 2512        secret_store_id=None,
 2513        tags=None,
 2514        tenant_id=None,
 2515    ):
 2516        self.app_id = app_id if app_id is not None else ''
 2517        self.bind_interface = bind_interface if bind_interface is not None else ''
 2518        '''
 2519         Bind interface
 2520        '''
 2521        self.client_certificate = client_certificate if client_certificate is not None else ''
 2522        self.egress_filter = egress_filter if egress_filter is not None else ''
 2523        '''
 2524         A filter applied to the routing logic to pin datasource to nodes.
 2525        '''
 2526        self.healthy = healthy if healthy is not None else False
 2527        '''
 2528         True if the datasource is reachable and the credentials are valid.
 2529        '''
 2530        self.id = id if id is not None else ''
 2531        '''
 2532         Unique identifier of the Resource.
 2533        '''
 2534        self.name = name if name is not None else ''
 2535        '''
 2536         Unique human-readable name of the Resource.
 2537        '''
 2538        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2539        '''
 2540         ID of the secret store containing credentials for this resource, if any.
 2541        '''
 2542        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2543        '''
 2544         Tags is a map of key, value pairs.
 2545        '''
 2546        self.tenant_id = tenant_id if tenant_id is not None else ''
 2547
 2548    def __repr__(self):
 2549        return '<sdm.AzureCertificate ' + \
 2550            'app_id: ' + repr(self.app_id) + ' ' +\
 2551            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2552            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2553            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2554            'healthy: ' + repr(self.healthy) + ' ' +\
 2555            'id: ' + repr(self.id) + ' ' +\
 2556            'name: ' + repr(self.name) + ' ' +\
 2557            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2558            'tags: ' + repr(self.tags) + ' ' +\
 2559            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2560            '>'
 2561
 2562    def to_dict(self):
 2563        return {
 2564            'app_id': self.app_id,
 2565            'bind_interface': self.bind_interface,
 2566            'client_certificate': self.client_certificate,
 2567            'egress_filter': self.egress_filter,
 2568            'healthy': self.healthy,
 2569            'id': self.id,
 2570            'name': self.name,
 2571            'secret_store_id': self.secret_store_id,
 2572            'tags': self.tags,
 2573            'tenant_id': self.tenant_id,
 2574        }
 2575
 2576    @classmethod
 2577    def from_dict(cls, d):
 2578        return cls(
 2579            app_id=d.get('app_id'),
 2580            bind_interface=d.get('bind_interface'),
 2581            client_certificate=d.get('client_certificate'),
 2582            egress_filter=d.get('egress_filter'),
 2583            healthy=d.get('healthy'),
 2584            id=d.get('id'),
 2585            name=d.get('name'),
 2586            secret_store_id=d.get('secret_store_id'),
 2587            tags=d.get('tags'),
 2588            tenant_id=d.get('tenant_id'),
 2589        )
 2590
 2591
 2592class AzurePostgres:
 2593    __slots__ = [
 2594        'bind_interface',
 2595        'database',
 2596        'egress_filter',
 2597        'healthy',
 2598        'hostname',
 2599        'id',
 2600        'name',
 2601        'override_database',
 2602        'password',
 2603        'port',
 2604        'port_override',
 2605        'secret_store_id',
 2606        'tags',
 2607        'username',
 2608    ]
 2609
 2610    def __init__(
 2611        self,
 2612        bind_interface=None,
 2613        database=None,
 2614        egress_filter=None,
 2615        healthy=None,
 2616        hostname=None,
 2617        id=None,
 2618        name=None,
 2619        override_database=None,
 2620        password=None,
 2621        port=None,
 2622        port_override=None,
 2623        secret_store_id=None,
 2624        tags=None,
 2625        username=None,
 2626    ):
 2627        self.bind_interface = bind_interface if bind_interface is not None else ''
 2628        '''
 2629         Bind interface
 2630        '''
 2631        self.database = database if database is not None else ''
 2632        self.egress_filter = egress_filter if egress_filter is not None else ''
 2633        '''
 2634         A filter applied to the routing logic to pin datasource to nodes.
 2635        '''
 2636        self.healthy = healthy if healthy is not None else False
 2637        '''
 2638         True if the datasource is reachable and the credentials are valid.
 2639        '''
 2640        self.hostname = hostname if hostname is not None else ''
 2641        self.id = id if id is not None else ''
 2642        '''
 2643         Unique identifier of the Resource.
 2644        '''
 2645        self.name = name if name is not None else ''
 2646        '''
 2647         Unique human-readable name of the Resource.
 2648        '''
 2649        self.override_database = override_database if override_database is not None else False
 2650        self.password = password if password is not None else ''
 2651        self.port = port if port is not None else 0
 2652        self.port_override = port_override if port_override is not None else 0
 2653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2654        '''
 2655         ID of the secret store containing credentials for this resource, if any.
 2656        '''
 2657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2658        '''
 2659         Tags is a map of key, value pairs.
 2660        '''
 2661        self.username = username if username is not None else ''
 2662
 2663    def __repr__(self):
 2664        return '<sdm.AzurePostgres ' + \
 2665            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2666            'database: ' + repr(self.database) + ' ' +\
 2667            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2668            'healthy: ' + repr(self.healthy) + ' ' +\
 2669            'hostname: ' + repr(self.hostname) + ' ' +\
 2670            'id: ' + repr(self.id) + ' ' +\
 2671            'name: ' + repr(self.name) + ' ' +\
 2672            'override_database: ' + repr(self.override_database) + ' ' +\
 2673            'password: ' + repr(self.password) + ' ' +\
 2674            'port: ' + repr(self.port) + ' ' +\
 2675            'port_override: ' + repr(self.port_override) + ' ' +\
 2676            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2677            'tags: ' + repr(self.tags) + ' ' +\
 2678            'username: ' + repr(self.username) + ' ' +\
 2679            '>'
 2680
 2681    def to_dict(self):
 2682        return {
 2683            'bind_interface': self.bind_interface,
 2684            'database': self.database,
 2685            'egress_filter': self.egress_filter,
 2686            'healthy': self.healthy,
 2687            'hostname': self.hostname,
 2688            'id': self.id,
 2689            'name': self.name,
 2690            'override_database': self.override_database,
 2691            'password': self.password,
 2692            'port': self.port,
 2693            'port_override': self.port_override,
 2694            'secret_store_id': self.secret_store_id,
 2695            'tags': self.tags,
 2696            'username': self.username,
 2697        }
 2698
 2699    @classmethod
 2700    def from_dict(cls, d):
 2701        return cls(
 2702            bind_interface=d.get('bind_interface'),
 2703            database=d.get('database'),
 2704            egress_filter=d.get('egress_filter'),
 2705            healthy=d.get('healthy'),
 2706            hostname=d.get('hostname'),
 2707            id=d.get('id'),
 2708            name=d.get('name'),
 2709            override_database=d.get('override_database'),
 2710            password=d.get('password'),
 2711            port=d.get('port'),
 2712            port_override=d.get('port_override'),
 2713            secret_store_id=d.get('secret_store_id'),
 2714            tags=d.get('tags'),
 2715            username=d.get('username'),
 2716        )
 2717
 2718
 2719class AzureStore:
 2720    __slots__ = [
 2721        'id',
 2722        'name',
 2723        'tags',
 2724        'vault_uri',
 2725    ]
 2726
 2727    def __init__(
 2728        self,
 2729        id=None,
 2730        name=None,
 2731        tags=None,
 2732        vault_uri=None,
 2733    ):
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the SecretStore.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the SecretStore.
 2741        '''
 2742        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2743        '''
 2744         Tags is a map of key, value pairs.
 2745        '''
 2746        self.vault_uri = vault_uri if vault_uri is not None else ''
 2747
 2748    def __repr__(self):
 2749        return '<sdm.AzureStore ' + \
 2750            'id: ' + repr(self.id) + ' ' +\
 2751            'name: ' + repr(self.name) + ' ' +\
 2752            'tags: ' + repr(self.tags) + ' ' +\
 2753            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 2754            '>'
 2755
 2756    def to_dict(self):
 2757        return {
 2758            'id': self.id,
 2759            'name': self.name,
 2760            'tags': self.tags,
 2761            'vault_uri': self.vault_uri,
 2762        }
 2763
 2764    @classmethod
 2765    def from_dict(cls, d):
 2766        return cls(
 2767            id=d.get('id'),
 2768            name=d.get('name'),
 2769            tags=d.get('tags'),
 2770            vault_uri=d.get('vault_uri'),
 2771        )
 2772
 2773
 2774class BigQuery:
 2775    __slots__ = [
 2776        'bind_interface',
 2777        'egress_filter',
 2778        'endpoint',
 2779        'healthy',
 2780        'id',
 2781        'name',
 2782        'port_override',
 2783        'private_key',
 2784        'project',
 2785        'secret_store_id',
 2786        'tags',
 2787        'username',
 2788    ]
 2789
 2790    def __init__(
 2791        self,
 2792        bind_interface=None,
 2793        egress_filter=None,
 2794        endpoint=None,
 2795        healthy=None,
 2796        id=None,
 2797        name=None,
 2798        port_override=None,
 2799        private_key=None,
 2800        project=None,
 2801        secret_store_id=None,
 2802        tags=None,
 2803        username=None,
 2804    ):
 2805        self.bind_interface = bind_interface if bind_interface is not None else ''
 2806        '''
 2807         Bind interface
 2808        '''
 2809        self.egress_filter = egress_filter if egress_filter is not None else ''
 2810        '''
 2811         A filter applied to the routing logic to pin datasource to nodes.
 2812        '''
 2813        self.endpoint = endpoint if endpoint is not None else ''
 2814        self.healthy = healthy if healthy is not None else False
 2815        '''
 2816         True if the datasource is reachable and the credentials are valid.
 2817        '''
 2818        self.id = id if id is not None else ''
 2819        '''
 2820         Unique identifier of the Resource.
 2821        '''
 2822        self.name = name if name is not None else ''
 2823        '''
 2824         Unique human-readable name of the Resource.
 2825        '''
 2826        self.port_override = port_override if port_override is not None else 0
 2827        self.private_key = private_key if private_key is not None else ''
 2828        self.project = project if project is not None else ''
 2829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2830        '''
 2831         ID of the secret store containing credentials for this resource, if any.
 2832        '''
 2833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2834        '''
 2835         Tags is a map of key, value pairs.
 2836        '''
 2837        self.username = username if username is not None else ''
 2838
 2839    def __repr__(self):
 2840        return '<sdm.BigQuery ' + \
 2841            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2842            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2843            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2844            'healthy: ' + repr(self.healthy) + ' ' +\
 2845            'id: ' + repr(self.id) + ' ' +\
 2846            'name: ' + repr(self.name) + ' ' +\
 2847            'port_override: ' + repr(self.port_override) + ' ' +\
 2848            'private_key: ' + repr(self.private_key) + ' ' +\
 2849            'project: ' + repr(self.project) + ' ' +\
 2850            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2851            'tags: ' + repr(self.tags) + ' ' +\
 2852            'username: ' + repr(self.username) + ' ' +\
 2853            '>'
 2854
 2855    def to_dict(self):
 2856        return {
 2857            'bind_interface': self.bind_interface,
 2858            'egress_filter': self.egress_filter,
 2859            'endpoint': self.endpoint,
 2860            'healthy': self.healthy,
 2861            'id': self.id,
 2862            'name': self.name,
 2863            'port_override': self.port_override,
 2864            'private_key': self.private_key,
 2865            'project': self.project,
 2866            'secret_store_id': self.secret_store_id,
 2867            'tags': self.tags,
 2868            'username': self.username,
 2869        }
 2870
 2871    @classmethod
 2872    def from_dict(cls, d):
 2873        return cls(
 2874            bind_interface=d.get('bind_interface'),
 2875            egress_filter=d.get('egress_filter'),
 2876            endpoint=d.get('endpoint'),
 2877            healthy=d.get('healthy'),
 2878            id=d.get('id'),
 2879            name=d.get('name'),
 2880            port_override=d.get('port_override'),
 2881            private_key=d.get('private_key'),
 2882            project=d.get('project'),
 2883            secret_store_id=d.get('secret_store_id'),
 2884            tags=d.get('tags'),
 2885            username=d.get('username'),
 2886        )
 2887
 2888
 2889class Cassandra:
 2890    __slots__ = [
 2891        'bind_interface',
 2892        'egress_filter',
 2893        'healthy',
 2894        'hostname',
 2895        'id',
 2896        'name',
 2897        'password',
 2898        'port',
 2899        'port_override',
 2900        'secret_store_id',
 2901        'tags',
 2902        'tls_required',
 2903        'username',
 2904    ]
 2905
 2906    def __init__(
 2907        self,
 2908        bind_interface=None,
 2909        egress_filter=None,
 2910        healthy=None,
 2911        hostname=None,
 2912        id=None,
 2913        name=None,
 2914        password=None,
 2915        port=None,
 2916        port_override=None,
 2917        secret_store_id=None,
 2918        tags=None,
 2919        tls_required=None,
 2920        username=None,
 2921    ):
 2922        self.bind_interface = bind_interface if bind_interface is not None else ''
 2923        '''
 2924         Bind interface
 2925        '''
 2926        self.egress_filter = egress_filter if egress_filter is not None else ''
 2927        '''
 2928         A filter applied to the routing logic to pin datasource to nodes.
 2929        '''
 2930        self.healthy = healthy if healthy is not None else False
 2931        '''
 2932         True if the datasource is reachable and the credentials are valid.
 2933        '''
 2934        self.hostname = hostname if hostname is not None else ''
 2935        self.id = id if id is not None else ''
 2936        '''
 2937         Unique identifier of the Resource.
 2938        '''
 2939        self.name = name if name is not None else ''
 2940        '''
 2941         Unique human-readable name of the Resource.
 2942        '''
 2943        self.password = password if password is not None else ''
 2944        self.port = port if port is not None else 0
 2945        self.port_override = port_override if port_override is not None else 0
 2946        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2947        '''
 2948         ID of the secret store containing credentials for this resource, if any.
 2949        '''
 2950        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2951        '''
 2952         Tags is a map of key, value pairs.
 2953        '''
 2954        self.tls_required = tls_required if tls_required is not None else False
 2955        self.username = username if username is not None else ''
 2956
 2957    def __repr__(self):
 2958        return '<sdm.Cassandra ' + \
 2959            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2960            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2961            'healthy: ' + repr(self.healthy) + ' ' +\
 2962            'hostname: ' + repr(self.hostname) + ' ' +\
 2963            'id: ' + repr(self.id) + ' ' +\
 2964            'name: ' + repr(self.name) + ' ' +\
 2965            'password: ' + repr(self.password) + ' ' +\
 2966            'port: ' + repr(self.port) + ' ' +\
 2967            'port_override: ' + repr(self.port_override) + ' ' +\
 2968            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2969            'tags: ' + repr(self.tags) + ' ' +\
 2970            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2971            'username: ' + repr(self.username) + ' ' +\
 2972            '>'
 2973
 2974    def to_dict(self):
 2975        return {
 2976            'bind_interface': self.bind_interface,
 2977            'egress_filter': self.egress_filter,
 2978            'healthy': self.healthy,
 2979            'hostname': self.hostname,
 2980            'id': self.id,
 2981            'name': self.name,
 2982            'password': self.password,
 2983            'port': self.port,
 2984            'port_override': self.port_override,
 2985            'secret_store_id': self.secret_store_id,
 2986            'tags': self.tags,
 2987            'tls_required': self.tls_required,
 2988            'username': self.username,
 2989        }
 2990
 2991    @classmethod
 2992    def from_dict(cls, d):
 2993        return cls(
 2994            bind_interface=d.get('bind_interface'),
 2995            egress_filter=d.get('egress_filter'),
 2996            healthy=d.get('healthy'),
 2997            hostname=d.get('hostname'),
 2998            id=d.get('id'),
 2999            name=d.get('name'),
 3000            password=d.get('password'),
 3001            port=d.get('port'),
 3002            port_override=d.get('port_override'),
 3003            secret_store_id=d.get('secret_store_id'),
 3004            tags=d.get('tags'),
 3005            tls_required=d.get('tls_required'),
 3006            username=d.get('username'),
 3007        )
 3008
 3009
 3010class Citus:
 3011    __slots__ = [
 3012        'bind_interface',
 3013        'database',
 3014        'egress_filter',
 3015        'healthy',
 3016        'hostname',
 3017        'id',
 3018        'name',
 3019        'override_database',
 3020        'password',
 3021        'port',
 3022        'port_override',
 3023        'secret_store_id',
 3024        'tags',
 3025        'username',
 3026    ]
 3027
 3028    def __init__(
 3029        self,
 3030        bind_interface=None,
 3031        database=None,
 3032        egress_filter=None,
 3033        healthy=None,
 3034        hostname=None,
 3035        id=None,
 3036        name=None,
 3037        override_database=None,
 3038        password=None,
 3039        port=None,
 3040        port_override=None,
 3041        secret_store_id=None,
 3042        tags=None,
 3043        username=None,
 3044    ):
 3045        self.bind_interface = bind_interface if bind_interface is not None else ''
 3046        '''
 3047         Bind interface
 3048        '''
 3049        self.database = database if database is not None else ''
 3050        self.egress_filter = egress_filter if egress_filter is not None else ''
 3051        '''
 3052         A filter applied to the routing logic to pin datasource to nodes.
 3053        '''
 3054        self.healthy = healthy if healthy is not None else False
 3055        '''
 3056         True if the datasource is reachable and the credentials are valid.
 3057        '''
 3058        self.hostname = hostname if hostname is not None else ''
 3059        self.id = id if id is not None else ''
 3060        '''
 3061         Unique identifier of the Resource.
 3062        '''
 3063        self.name = name if name is not None else ''
 3064        '''
 3065         Unique human-readable name of the Resource.
 3066        '''
 3067        self.override_database = override_database if override_database is not None else False
 3068        self.password = password if password is not None else ''
 3069        self.port = port if port is not None else 0
 3070        self.port_override = port_override if port_override is not None else 0
 3071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3072        '''
 3073         ID of the secret store containing credentials for this resource, if any.
 3074        '''
 3075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3076        '''
 3077         Tags is a map of key, value pairs.
 3078        '''
 3079        self.username = username if username is not None else ''
 3080
 3081    def __repr__(self):
 3082        return '<sdm.Citus ' + \
 3083            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3084            'database: ' + repr(self.database) + ' ' +\
 3085            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3086            'healthy: ' + repr(self.healthy) + ' ' +\
 3087            'hostname: ' + repr(self.hostname) + ' ' +\
 3088            'id: ' + repr(self.id) + ' ' +\
 3089            'name: ' + repr(self.name) + ' ' +\
 3090            'override_database: ' + repr(self.override_database) + ' ' +\
 3091            'password: ' + repr(self.password) + ' ' +\
 3092            'port: ' + repr(self.port) + ' ' +\
 3093            'port_override: ' + repr(self.port_override) + ' ' +\
 3094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3095            'tags: ' + repr(self.tags) + ' ' +\
 3096            'username: ' + repr(self.username) + ' ' +\
 3097            '>'
 3098
 3099    def to_dict(self):
 3100        return {
 3101            'bind_interface': self.bind_interface,
 3102            'database': self.database,
 3103            'egress_filter': self.egress_filter,
 3104            'healthy': self.healthy,
 3105            'hostname': self.hostname,
 3106            'id': self.id,
 3107            'name': self.name,
 3108            'override_database': self.override_database,
 3109            'password': self.password,
 3110            'port': self.port,
 3111            'port_override': self.port_override,
 3112            'secret_store_id': self.secret_store_id,
 3113            'tags': self.tags,
 3114            'username': self.username,
 3115        }
 3116
 3117    @classmethod
 3118    def from_dict(cls, d):
 3119        return cls(
 3120            bind_interface=d.get('bind_interface'),
 3121            database=d.get('database'),
 3122            egress_filter=d.get('egress_filter'),
 3123            healthy=d.get('healthy'),
 3124            hostname=d.get('hostname'),
 3125            id=d.get('id'),
 3126            name=d.get('name'),
 3127            override_database=d.get('override_database'),
 3128            password=d.get('password'),
 3129            port=d.get('port'),
 3130            port_override=d.get('port_override'),
 3131            secret_store_id=d.get('secret_store_id'),
 3132            tags=d.get('tags'),
 3133            username=d.get('username'),
 3134        )
 3135
 3136
 3137class Clustrix:
 3138    __slots__ = [
 3139        'bind_interface',
 3140        'database',
 3141        'egress_filter',
 3142        'healthy',
 3143        'hostname',
 3144        'id',
 3145        'name',
 3146        'password',
 3147        'port',
 3148        'port_override',
 3149        'secret_store_id',
 3150        'tags',
 3151        'username',
 3152    ]
 3153
 3154    def __init__(
 3155        self,
 3156        bind_interface=None,
 3157        database=None,
 3158        egress_filter=None,
 3159        healthy=None,
 3160        hostname=None,
 3161        id=None,
 3162        name=None,
 3163        password=None,
 3164        port=None,
 3165        port_override=None,
 3166        secret_store_id=None,
 3167        tags=None,
 3168        username=None,
 3169    ):
 3170        self.bind_interface = bind_interface if bind_interface is not None else ''
 3171        '''
 3172         Bind interface
 3173        '''
 3174        self.database = database if database is not None else ''
 3175        self.egress_filter = egress_filter if egress_filter is not None else ''
 3176        '''
 3177         A filter applied to the routing logic to pin datasource to nodes.
 3178        '''
 3179        self.healthy = healthy if healthy is not None else False
 3180        '''
 3181         True if the datasource is reachable and the credentials are valid.
 3182        '''
 3183        self.hostname = hostname if hostname is not None else ''
 3184        self.id = id if id is not None else ''
 3185        '''
 3186         Unique identifier of the Resource.
 3187        '''
 3188        self.name = name if name is not None else ''
 3189        '''
 3190         Unique human-readable name of the Resource.
 3191        '''
 3192        self.password = password if password is not None else ''
 3193        self.port = port if port is not None else 0
 3194        self.port_override = port_override if port_override is not None else 0
 3195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3196        '''
 3197         ID of the secret store containing credentials for this resource, if any.
 3198        '''
 3199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3200        '''
 3201         Tags is a map of key, value pairs.
 3202        '''
 3203        self.username = username if username is not None else ''
 3204
 3205    def __repr__(self):
 3206        return '<sdm.Clustrix ' + \
 3207            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3208            'database: ' + repr(self.database) + ' ' +\
 3209            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3210            'healthy: ' + repr(self.healthy) + ' ' +\
 3211            'hostname: ' + repr(self.hostname) + ' ' +\
 3212            'id: ' + repr(self.id) + ' ' +\
 3213            'name: ' + repr(self.name) + ' ' +\
 3214            'password: ' + repr(self.password) + ' ' +\
 3215            'port: ' + repr(self.port) + ' ' +\
 3216            'port_override: ' + repr(self.port_override) + ' ' +\
 3217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3218            'tags: ' + repr(self.tags) + ' ' +\
 3219            'username: ' + repr(self.username) + ' ' +\
 3220            '>'
 3221
 3222    def to_dict(self):
 3223        return {
 3224            'bind_interface': self.bind_interface,
 3225            'database': self.database,
 3226            'egress_filter': self.egress_filter,
 3227            'healthy': self.healthy,
 3228            'hostname': self.hostname,
 3229            'id': self.id,
 3230            'name': self.name,
 3231            'password': self.password,
 3232            'port': self.port,
 3233            'port_override': self.port_override,
 3234            'secret_store_id': self.secret_store_id,
 3235            'tags': self.tags,
 3236            'username': self.username,
 3237        }
 3238
 3239    @classmethod
 3240    def from_dict(cls, d):
 3241        return cls(
 3242            bind_interface=d.get('bind_interface'),
 3243            database=d.get('database'),
 3244            egress_filter=d.get('egress_filter'),
 3245            healthy=d.get('healthy'),
 3246            hostname=d.get('hostname'),
 3247            id=d.get('id'),
 3248            name=d.get('name'),
 3249            password=d.get('password'),
 3250            port=d.get('port'),
 3251            port_override=d.get('port_override'),
 3252            secret_store_id=d.get('secret_store_id'),
 3253            tags=d.get('tags'),
 3254            username=d.get('username'),
 3255        )
 3256
 3257
 3258class Cockroach:
 3259    __slots__ = [
 3260        'bind_interface',
 3261        'database',
 3262        'egress_filter',
 3263        'healthy',
 3264        'hostname',
 3265        'id',
 3266        'name',
 3267        'override_database',
 3268        'password',
 3269        'port',
 3270        'port_override',
 3271        'secret_store_id',
 3272        'tags',
 3273        'username',
 3274    ]
 3275
 3276    def __init__(
 3277        self,
 3278        bind_interface=None,
 3279        database=None,
 3280        egress_filter=None,
 3281        healthy=None,
 3282        hostname=None,
 3283        id=None,
 3284        name=None,
 3285        override_database=None,
 3286        password=None,
 3287        port=None,
 3288        port_override=None,
 3289        secret_store_id=None,
 3290        tags=None,
 3291        username=None,
 3292    ):
 3293        self.bind_interface = bind_interface if bind_interface is not None else ''
 3294        '''
 3295         Bind interface
 3296        '''
 3297        self.database = database if database is not None else ''
 3298        self.egress_filter = egress_filter if egress_filter is not None else ''
 3299        '''
 3300         A filter applied to the routing logic to pin datasource to nodes.
 3301        '''
 3302        self.healthy = healthy if healthy is not None else False
 3303        '''
 3304         True if the datasource is reachable and the credentials are valid.
 3305        '''
 3306        self.hostname = hostname if hostname is not None else ''
 3307        self.id = id if id is not None else ''
 3308        '''
 3309         Unique identifier of the Resource.
 3310        '''
 3311        self.name = name if name is not None else ''
 3312        '''
 3313         Unique human-readable name of the Resource.
 3314        '''
 3315        self.override_database = override_database if override_database is not None else False
 3316        self.password = password if password is not None else ''
 3317        self.port = port if port is not None else 0
 3318        self.port_override = port_override if port_override is not None else 0
 3319        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3320        '''
 3321         ID of the secret store containing credentials for this resource, if any.
 3322        '''
 3323        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3324        '''
 3325         Tags is a map of key, value pairs.
 3326        '''
 3327        self.username = username if username is not None else ''
 3328
 3329    def __repr__(self):
 3330        return '<sdm.Cockroach ' + \
 3331            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3332            'database: ' + repr(self.database) + ' ' +\
 3333            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3334            'healthy: ' + repr(self.healthy) + ' ' +\
 3335            'hostname: ' + repr(self.hostname) + ' ' +\
 3336            'id: ' + repr(self.id) + ' ' +\
 3337            'name: ' + repr(self.name) + ' ' +\
 3338            'override_database: ' + repr(self.override_database) + ' ' +\
 3339            'password: ' + repr(self.password) + ' ' +\
 3340            'port: ' + repr(self.port) + ' ' +\
 3341            'port_override: ' + repr(self.port_override) + ' ' +\
 3342            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3343            'tags: ' + repr(self.tags) + ' ' +\
 3344            'username: ' + repr(self.username) + ' ' +\
 3345            '>'
 3346
 3347    def to_dict(self):
 3348        return {
 3349            'bind_interface': self.bind_interface,
 3350            'database': self.database,
 3351            'egress_filter': self.egress_filter,
 3352            'healthy': self.healthy,
 3353            'hostname': self.hostname,
 3354            'id': self.id,
 3355            'name': self.name,
 3356            'override_database': self.override_database,
 3357            'password': self.password,
 3358            'port': self.port,
 3359            'port_override': self.port_override,
 3360            'secret_store_id': self.secret_store_id,
 3361            'tags': self.tags,
 3362            'username': self.username,
 3363        }
 3364
 3365    @classmethod
 3366    def from_dict(cls, d):
 3367        return cls(
 3368            bind_interface=d.get('bind_interface'),
 3369            database=d.get('database'),
 3370            egress_filter=d.get('egress_filter'),
 3371            healthy=d.get('healthy'),
 3372            hostname=d.get('hostname'),
 3373            id=d.get('id'),
 3374            name=d.get('name'),
 3375            override_database=d.get('override_database'),
 3376            password=d.get('password'),
 3377            port=d.get('port'),
 3378            port_override=d.get('port_override'),
 3379            secret_store_id=d.get('secret_store_id'),
 3380            tags=d.get('tags'),
 3381            username=d.get('username'),
 3382        )
 3383
 3384
 3385class ConjurClientStore:
 3386    '''
 3387    ConjurClientStore is currently unstable, and its API may change, or it may be removed,
 3388    without a major version bump.
 3389    '''
 3390    __slots__ = [
 3391        'appurl',
 3392        'id',
 3393        'name',
 3394        'tags',
 3395    ]
 3396
 3397    def __init__(
 3398        self,
 3399        appurl=None,
 3400        id=None,
 3401        name=None,
 3402        tags=None,
 3403    ):
 3404        self.appurl = appurl if appurl is not None else ''
 3405        self.id = id if id is not None else ''
 3406        '''
 3407         Unique identifier of the SecretStore.
 3408        '''
 3409        self.name = name if name is not None else ''
 3410        '''
 3411         Unique human-readable name of the SecretStore.
 3412        '''
 3413        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3414        '''
 3415         Tags is a map of key, value pairs.
 3416        '''
 3417
 3418    def __repr__(self):
 3419        return '<sdm.ConjurClientStore ' + \
 3420            'appurl: ' + repr(self.appurl) + ' ' +\
 3421            'id: ' + repr(self.id) + ' ' +\
 3422            'name: ' + repr(self.name) + ' ' +\
 3423            'tags: ' + repr(self.tags) + ' ' +\
 3424            '>'
 3425
 3426    def to_dict(self):
 3427        return {
 3428            'appurl': self.appurl,
 3429            'id': self.id,
 3430            'name': self.name,
 3431            'tags': self.tags,
 3432        }
 3433
 3434    @classmethod
 3435    def from_dict(cls, d):
 3436        return cls(
 3437            appurl=d.get('appurl'),
 3438            id=d.get('id'),
 3439            name=d.get('name'),
 3440            tags=d.get('tags'),
 3441        )
 3442
 3443
 3444class ControlPanelGetSSHCAPublicKeyResponse:
 3445    '''
 3446         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3447     organization's SSH Certificate Authority public key.
 3448    '''
 3449    __slots__ = [
 3450        'meta',
 3451        'public_key',
 3452        'rate_limit',
 3453    ]
 3454
 3455    def __init__(
 3456        self,
 3457        meta=None,
 3458        public_key=None,
 3459        rate_limit=None,
 3460    ):
 3461        self.meta = meta if meta is not None else None
 3462        '''
 3463         Reserved for future use.
 3464        '''
 3465        self.public_key = public_key if public_key is not None else ''
 3466        '''
 3467         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3468         key format.
 3469        '''
 3470        self.rate_limit = rate_limit if rate_limit is not None else None
 3471        '''
 3472         Rate limit information.
 3473        '''
 3474
 3475    def __repr__(self):
 3476        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3477            'meta: ' + repr(self.meta) + ' ' +\
 3478            'public_key: ' + repr(self.public_key) + ' ' +\
 3479            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3480            '>'
 3481
 3482    def to_dict(self):
 3483        return {
 3484            'meta': self.meta,
 3485            'public_key': self.public_key,
 3486            'rate_limit': self.rate_limit,
 3487        }
 3488
 3489    @classmethod
 3490    def from_dict(cls, d):
 3491        return cls(
 3492            meta=d.get('meta'),
 3493            public_key=d.get('public_key'),
 3494            rate_limit=d.get('rate_limit'),
 3495        )
 3496
 3497
 3498class ControlPanelVerifyJWTResponse:
 3499    '''
 3500         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3501    '''
 3502    __slots__ = [
 3503        'meta',
 3504        'rate_limit',
 3505        'valid',
 3506    ]
 3507
 3508    def __init__(
 3509        self,
 3510        meta=None,
 3511        rate_limit=None,
 3512        valid=None,
 3513    ):
 3514        self.meta = meta if meta is not None else None
 3515        '''
 3516         Reserved for future use.
 3517        '''
 3518        self.rate_limit = rate_limit if rate_limit is not None else None
 3519        '''
 3520         Rate limit information.
 3521        '''
 3522        self.valid = valid if valid is not None else False
 3523        '''
 3524         Reports if the given token is valid.
 3525        '''
 3526
 3527    def __repr__(self):
 3528        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3529            'meta: ' + repr(self.meta) + ' ' +\
 3530            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3531            'valid: ' + repr(self.valid) + ' ' +\
 3532            '>'
 3533
 3534    def to_dict(self):
 3535        return {
 3536            'meta': self.meta,
 3537            'rate_limit': self.rate_limit,
 3538            'valid': self.valid,
 3539        }
 3540
 3541    @classmethod
 3542    def from_dict(cls, d):
 3543        return cls(
 3544            meta=d.get('meta'),
 3545            rate_limit=d.get('rate_limit'),
 3546            valid=d.get('valid'),
 3547        )
 3548
 3549
 3550class CreateResponseMetadata:
 3551    '''
 3552         CreateResponseMetadata is reserved for future use.
 3553    '''
 3554    __slots__ = []
 3555
 3556    def __init__(self, ):
 3557        pass
 3558
 3559    def __repr__(self):
 3560        return '<sdm.CreateResponseMetadata ' + \
 3561            '>'
 3562
 3563    def to_dict(self):
 3564        return {}
 3565
 3566    @classmethod
 3567    def from_dict(cls, d):
 3568        return cls()
 3569
 3570
 3571class DB2I:
 3572    __slots__ = [
 3573        'bind_interface',
 3574        'egress_filter',
 3575        'healthy',
 3576        'hostname',
 3577        'id',
 3578        'name',
 3579        'password',
 3580        'port',
 3581        'port_override',
 3582        'secret_store_id',
 3583        'tags',
 3584        'tls_required',
 3585        'username',
 3586    ]
 3587
 3588    def __init__(
 3589        self,
 3590        bind_interface=None,
 3591        egress_filter=None,
 3592        healthy=None,
 3593        hostname=None,
 3594        id=None,
 3595        name=None,
 3596        password=None,
 3597        port=None,
 3598        port_override=None,
 3599        secret_store_id=None,
 3600        tags=None,
 3601        tls_required=None,
 3602        username=None,
 3603    ):
 3604        self.bind_interface = bind_interface if bind_interface is not None else ''
 3605        '''
 3606         Bind interface
 3607        '''
 3608        self.egress_filter = egress_filter if egress_filter is not None else ''
 3609        '''
 3610         A filter applied to the routing logic to pin datasource to nodes.
 3611        '''
 3612        self.healthy = healthy if healthy is not None else False
 3613        '''
 3614         True if the datasource is reachable and the credentials are valid.
 3615        '''
 3616        self.hostname = hostname if hostname is not None else ''
 3617        self.id = id if id is not None else ''
 3618        '''
 3619         Unique identifier of the Resource.
 3620        '''
 3621        self.name = name if name is not None else ''
 3622        '''
 3623         Unique human-readable name of the Resource.
 3624        '''
 3625        self.password = password if password is not None else ''
 3626        self.port = port if port is not None else 0
 3627        self.port_override = port_override if port_override is not None else 0
 3628        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3629        '''
 3630         ID of the secret store containing credentials for this resource, if any.
 3631        '''
 3632        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3633        '''
 3634         Tags is a map of key, value pairs.
 3635        '''
 3636        self.tls_required = tls_required if tls_required is not None else False
 3637        self.username = username if username is not None else ''
 3638
 3639    def __repr__(self):
 3640        return '<sdm.DB2I ' + \
 3641            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3642            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3643            'healthy: ' + repr(self.healthy) + ' ' +\
 3644            'hostname: ' + repr(self.hostname) + ' ' +\
 3645            'id: ' + repr(self.id) + ' ' +\
 3646            'name: ' + repr(self.name) + ' ' +\
 3647            'password: ' + repr(self.password) + ' ' +\
 3648            'port: ' + repr(self.port) + ' ' +\
 3649            'port_override: ' + repr(self.port_override) + ' ' +\
 3650            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3651            'tags: ' + repr(self.tags) + ' ' +\
 3652            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3653            'username: ' + repr(self.username) + ' ' +\
 3654            '>'
 3655
 3656    def to_dict(self):
 3657        return {
 3658            'bind_interface': self.bind_interface,
 3659            'egress_filter': self.egress_filter,
 3660            'healthy': self.healthy,
 3661            'hostname': self.hostname,
 3662            'id': self.id,
 3663            'name': self.name,
 3664            'password': self.password,
 3665            'port': self.port,
 3666            'port_override': self.port_override,
 3667            'secret_store_id': self.secret_store_id,
 3668            'tags': self.tags,
 3669            'tls_required': self.tls_required,
 3670            'username': self.username,
 3671        }
 3672
 3673    @classmethod
 3674    def from_dict(cls, d):
 3675        return cls(
 3676            bind_interface=d.get('bind_interface'),
 3677            egress_filter=d.get('egress_filter'),
 3678            healthy=d.get('healthy'),
 3679            hostname=d.get('hostname'),
 3680            id=d.get('id'),
 3681            name=d.get('name'),
 3682            password=d.get('password'),
 3683            port=d.get('port'),
 3684            port_override=d.get('port_override'),
 3685            secret_store_id=d.get('secret_store_id'),
 3686            tags=d.get('tags'),
 3687            tls_required=d.get('tls_required'),
 3688            username=d.get('username'),
 3689        )
 3690
 3691
 3692class DB2LUW:
 3693    __slots__ = [
 3694        'bind_interface',
 3695        'database',
 3696        'egress_filter',
 3697        'healthy',
 3698        'hostname',
 3699        'id',
 3700        'name',
 3701        'password',
 3702        'port',
 3703        'port_override',
 3704        'secret_store_id',
 3705        'tags',
 3706        'username',
 3707    ]
 3708
 3709    def __init__(
 3710        self,
 3711        bind_interface=None,
 3712        database=None,
 3713        egress_filter=None,
 3714        healthy=None,
 3715        hostname=None,
 3716        id=None,
 3717        name=None,
 3718        password=None,
 3719        port=None,
 3720        port_override=None,
 3721        secret_store_id=None,
 3722        tags=None,
 3723        username=None,
 3724    ):
 3725        self.bind_interface = bind_interface if bind_interface is not None else ''
 3726        '''
 3727         Bind interface
 3728        '''
 3729        self.database = database if database is not None else ''
 3730        self.egress_filter = egress_filter if egress_filter is not None else ''
 3731        '''
 3732         A filter applied to the routing logic to pin datasource to nodes.
 3733        '''
 3734        self.healthy = healthy if healthy is not None else False
 3735        '''
 3736         True if the datasource is reachable and the credentials are valid.
 3737        '''
 3738        self.hostname = hostname if hostname is not None else ''
 3739        self.id = id if id is not None else ''
 3740        '''
 3741         Unique identifier of the Resource.
 3742        '''
 3743        self.name = name if name is not None else ''
 3744        '''
 3745         Unique human-readable name of the Resource.
 3746        '''
 3747        self.password = password if password is not None else ''
 3748        self.port = port if port is not None else 0
 3749        self.port_override = port_override if port_override is not None else 0
 3750        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3751        '''
 3752         ID of the secret store containing credentials for this resource, if any.
 3753        '''
 3754        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3755        '''
 3756         Tags is a map of key, value pairs.
 3757        '''
 3758        self.username = username if username is not None else ''
 3759
 3760    def __repr__(self):
 3761        return '<sdm.DB2LUW ' + \
 3762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3763            'database: ' + repr(self.database) + ' ' +\
 3764            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3765            'healthy: ' + repr(self.healthy) + ' ' +\
 3766            'hostname: ' + repr(self.hostname) + ' ' +\
 3767            'id: ' + repr(self.id) + ' ' +\
 3768            'name: ' + repr(self.name) + ' ' +\
 3769            'password: ' + repr(self.password) + ' ' +\
 3770            'port: ' + repr(self.port) + ' ' +\
 3771            'port_override: ' + repr(self.port_override) + ' ' +\
 3772            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3773            'tags: ' + repr(self.tags) + ' ' +\
 3774            'username: ' + repr(self.username) + ' ' +\
 3775            '>'
 3776
 3777    def to_dict(self):
 3778        return {
 3779            'bind_interface': self.bind_interface,
 3780            'database': self.database,
 3781            'egress_filter': self.egress_filter,
 3782            'healthy': self.healthy,
 3783            'hostname': self.hostname,
 3784            'id': self.id,
 3785            'name': self.name,
 3786            'password': self.password,
 3787            'port': self.port,
 3788            'port_override': self.port_override,
 3789            'secret_store_id': self.secret_store_id,
 3790            'tags': self.tags,
 3791            'username': self.username,
 3792        }
 3793
 3794    @classmethod
 3795    def from_dict(cls, d):
 3796        return cls(
 3797            bind_interface=d.get('bind_interface'),
 3798            database=d.get('database'),
 3799            egress_filter=d.get('egress_filter'),
 3800            healthy=d.get('healthy'),
 3801            hostname=d.get('hostname'),
 3802            id=d.get('id'),
 3803            name=d.get('name'),
 3804            password=d.get('password'),
 3805            port=d.get('port'),
 3806            port_override=d.get('port_override'),
 3807            secret_store_id=d.get('secret_store_id'),
 3808            tags=d.get('tags'),
 3809            username=d.get('username'),
 3810        )
 3811
 3812
 3813class DeleteResponseMetadata:
 3814    '''
 3815         DeleteResponseMetadata is reserved for future use.
 3816    '''
 3817    __slots__ = []
 3818
 3819    def __init__(self, ):
 3820        pass
 3821
 3822    def __repr__(self):
 3823        return '<sdm.DeleteResponseMetadata ' + \
 3824            '>'
 3825
 3826    def to_dict(self):
 3827        return {}
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls()
 3832
 3833
 3834class DelineaStore:
 3835    '''
 3836    DelineaStore is currently unstable, and its API may change, or it may be removed,
 3837    without a major version bump.
 3838    '''
 3839    __slots__ = [
 3840        'id',
 3841        'name',
 3842        'server_url',
 3843        'tags',
 3844        'tenant_name',
 3845    ]
 3846
 3847    def __init__(
 3848        self,
 3849        id=None,
 3850        name=None,
 3851        server_url=None,
 3852        tags=None,
 3853        tenant_name=None,
 3854    ):
 3855        self.id = id if id is not None else ''
 3856        '''
 3857         Unique identifier of the SecretStore.
 3858        '''
 3859        self.name = name if name is not None else ''
 3860        '''
 3861         Unique human-readable name of the SecretStore.
 3862        '''
 3863        self.server_url = server_url if server_url is not None else ''
 3864        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3865        '''
 3866         Tags is a map of key, value pairs.
 3867        '''
 3868        self.tenant_name = tenant_name if tenant_name is not None else ''
 3869
 3870    def __repr__(self):
 3871        return '<sdm.DelineaStore ' + \
 3872            'id: ' + repr(self.id) + ' ' +\
 3873            'name: ' + repr(self.name) + ' ' +\
 3874            'server_url: ' + repr(self.server_url) + ' ' +\
 3875            'tags: ' + repr(self.tags) + ' ' +\
 3876            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 3877            '>'
 3878
 3879    def to_dict(self):
 3880        return {
 3881            'id': self.id,
 3882            'name': self.name,
 3883            'server_url': self.server_url,
 3884            'tags': self.tags,
 3885            'tenant_name': self.tenant_name,
 3886        }
 3887
 3888    @classmethod
 3889    def from_dict(cls, d):
 3890        return cls(
 3891            id=d.get('id'),
 3892            name=d.get('name'),
 3893            server_url=d.get('server_url'),
 3894            tags=d.get('tags'),
 3895            tenant_name=d.get('tenant_name'),
 3896        )
 3897
 3898
 3899class DocumentDBHost:
 3900    __slots__ = [
 3901        'auth_database',
 3902        'bind_interface',
 3903        'egress_filter',
 3904        'healthy',
 3905        'hostname',
 3906        'id',
 3907        'name',
 3908        'password',
 3909        'port',
 3910        'port_override',
 3911        'secret_store_id',
 3912        'tags',
 3913        'username',
 3914    ]
 3915
 3916    def __init__(
 3917        self,
 3918        auth_database=None,
 3919        bind_interface=None,
 3920        egress_filter=None,
 3921        healthy=None,
 3922        hostname=None,
 3923        id=None,
 3924        name=None,
 3925        password=None,
 3926        port=None,
 3927        port_override=None,
 3928        secret_store_id=None,
 3929        tags=None,
 3930        username=None,
 3931    ):
 3932        self.auth_database = auth_database if auth_database is not None else ''
 3933        self.bind_interface = bind_interface if bind_interface is not None else ''
 3934        '''
 3935         Bind interface
 3936        '''
 3937        self.egress_filter = egress_filter if egress_filter is not None else ''
 3938        '''
 3939         A filter applied to the routing logic to pin datasource to nodes.
 3940        '''
 3941        self.healthy = healthy if healthy is not None else False
 3942        '''
 3943         True if the datasource is reachable and the credentials are valid.
 3944        '''
 3945        self.hostname = hostname if hostname is not None else ''
 3946        self.id = id if id is not None else ''
 3947        '''
 3948         Unique identifier of the Resource.
 3949        '''
 3950        self.name = name if name is not None else ''
 3951        '''
 3952         Unique human-readable name of the Resource.
 3953        '''
 3954        self.password = password if password is not None else ''
 3955        self.port = port if port is not None else 0
 3956        self.port_override = port_override if port_override is not None else 0
 3957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3958        '''
 3959         ID of the secret store containing credentials for this resource, if any.
 3960        '''
 3961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3962        '''
 3963         Tags is a map of key, value pairs.
 3964        '''
 3965        self.username = username if username is not None else ''
 3966
 3967    def __repr__(self):
 3968        return '<sdm.DocumentDBHost ' + \
 3969            'auth_database: ' + repr(self.auth_database) + ' ' +\
 3970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3971            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3972            'healthy: ' + repr(self.healthy) + ' ' +\
 3973            'hostname: ' + repr(self.hostname) + ' ' +\
 3974            'id: ' + repr(self.id) + ' ' +\
 3975            'name: ' + repr(self.name) + ' ' +\
 3976            'password: ' + repr(self.password) + ' ' +\
 3977            'port: ' + repr(self.port) + ' ' +\
 3978            'port_override: ' + repr(self.port_override) + ' ' +\
 3979            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3980            'tags: ' + repr(self.tags) + ' ' +\
 3981            'username: ' + repr(self.username) + ' ' +\
 3982            '>'
 3983
 3984    def to_dict(self):
 3985        return {
 3986            'auth_database': self.auth_database,
 3987            'bind_interface': self.bind_interface,
 3988            'egress_filter': self.egress_filter,
 3989            'healthy': self.healthy,
 3990            'hostname': self.hostname,
 3991            'id': self.id,
 3992            'name': self.name,
 3993            'password': self.password,
 3994            'port': self.port,
 3995            'port_override': self.port_override,
 3996            'secret_store_id': self.secret_store_id,
 3997            'tags': self.tags,
 3998            'username': self.username,
 3999        }
 4000
 4001    @classmethod
 4002    def from_dict(cls, d):
 4003        return cls(
 4004            auth_database=d.get('auth_database'),
 4005            bind_interface=d.get('bind_interface'),
 4006            egress_filter=d.get('egress_filter'),
 4007            healthy=d.get('healthy'),
 4008            hostname=d.get('hostname'),
 4009            id=d.get('id'),
 4010            name=d.get('name'),
 4011            password=d.get('password'),
 4012            port=d.get('port'),
 4013            port_override=d.get('port_override'),
 4014            secret_store_id=d.get('secret_store_id'),
 4015            tags=d.get('tags'),
 4016            username=d.get('username'),
 4017        )
 4018
 4019
 4020class DocumentDBReplicaSet:
 4021    __slots__ = [
 4022        'auth_database',
 4023        'bind_interface',
 4024        'connect_to_replica',
 4025        'egress_filter',
 4026        'healthy',
 4027        'hostname',
 4028        'id',
 4029        'name',
 4030        'password',
 4031        'port_override',
 4032        'replica_set',
 4033        'secret_store_id',
 4034        'tags',
 4035        'username',
 4036    ]
 4037
 4038    def __init__(
 4039        self,
 4040        auth_database=None,
 4041        bind_interface=None,
 4042        connect_to_replica=None,
 4043        egress_filter=None,
 4044        healthy=None,
 4045        hostname=None,
 4046        id=None,
 4047        name=None,
 4048        password=None,
 4049        port_override=None,
 4050        replica_set=None,
 4051        secret_store_id=None,
 4052        tags=None,
 4053        username=None,
 4054    ):
 4055        self.auth_database = auth_database if auth_database is not None else ''
 4056        self.bind_interface = bind_interface if bind_interface is not None else ''
 4057        '''
 4058         Bind interface
 4059        '''
 4060        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4061        self.egress_filter = egress_filter if egress_filter is not None else ''
 4062        '''
 4063         A filter applied to the routing logic to pin datasource to nodes.
 4064        '''
 4065        self.healthy = healthy if healthy is not None else False
 4066        '''
 4067         True if the datasource is reachable and the credentials are valid.
 4068        '''
 4069        self.hostname = hostname if hostname is not None else ''
 4070        '''
 4071         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4072        '''
 4073        self.id = id if id is not None else ''
 4074        '''
 4075         Unique identifier of the Resource.
 4076        '''
 4077        self.name = name if name is not None else ''
 4078        '''
 4079         Unique human-readable name of the Resource.
 4080        '''
 4081        self.password = password if password is not None else ''
 4082        self.port_override = port_override if port_override is not None else 0
 4083        self.replica_set = replica_set if replica_set is not None else ''
 4084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4085        '''
 4086         ID of the secret store containing credentials for this resource, if any.
 4087        '''
 4088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4089        '''
 4090         Tags is a map of key, value pairs.
 4091        '''
 4092        self.username = username if username is not None else ''
 4093
 4094    def __repr__(self):
 4095        return '<sdm.DocumentDBReplicaSet ' + \
 4096            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4097            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4098            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4099            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4100            'healthy: ' + repr(self.healthy) + ' ' +\
 4101            'hostname: ' + repr(self.hostname) + ' ' +\
 4102            'id: ' + repr(self.id) + ' ' +\
 4103            'name: ' + repr(self.name) + ' ' +\
 4104            'password: ' + repr(self.password) + ' ' +\
 4105            'port_override: ' + repr(self.port_override) + ' ' +\
 4106            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4107            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4108            'tags: ' + repr(self.tags) + ' ' +\
 4109            'username: ' + repr(self.username) + ' ' +\
 4110            '>'
 4111
 4112    def to_dict(self):
 4113        return {
 4114            'auth_database': self.auth_database,
 4115            'bind_interface': self.bind_interface,
 4116            'connect_to_replica': self.connect_to_replica,
 4117            'egress_filter': self.egress_filter,
 4118            'healthy': self.healthy,
 4119            'hostname': self.hostname,
 4120            'id': self.id,
 4121            'name': self.name,
 4122            'password': self.password,
 4123            'port_override': self.port_override,
 4124            'replica_set': self.replica_set,
 4125            'secret_store_id': self.secret_store_id,
 4126            'tags': self.tags,
 4127            'username': self.username,
 4128        }
 4129
 4130    @classmethod
 4131    def from_dict(cls, d):
 4132        return cls(
 4133            auth_database=d.get('auth_database'),
 4134            bind_interface=d.get('bind_interface'),
 4135            connect_to_replica=d.get('connect_to_replica'),
 4136            egress_filter=d.get('egress_filter'),
 4137            healthy=d.get('healthy'),
 4138            hostname=d.get('hostname'),
 4139            id=d.get('id'),
 4140            name=d.get('name'),
 4141            password=d.get('password'),
 4142            port_override=d.get('port_override'),
 4143            replica_set=d.get('replica_set'),
 4144            secret_store_id=d.get('secret_store_id'),
 4145            tags=d.get('tags'),
 4146            username=d.get('username'),
 4147        )
 4148
 4149
 4150class Druid:
 4151    __slots__ = [
 4152        'bind_interface',
 4153        'egress_filter',
 4154        'healthy',
 4155        'hostname',
 4156        'id',
 4157        'name',
 4158        'password',
 4159        'port',
 4160        'port_override',
 4161        'secret_store_id',
 4162        'tags',
 4163        'username',
 4164    ]
 4165
 4166    def __init__(
 4167        self,
 4168        bind_interface=None,
 4169        egress_filter=None,
 4170        healthy=None,
 4171        hostname=None,
 4172        id=None,
 4173        name=None,
 4174        password=None,
 4175        port=None,
 4176        port_override=None,
 4177        secret_store_id=None,
 4178        tags=None,
 4179        username=None,
 4180    ):
 4181        self.bind_interface = bind_interface if bind_interface is not None else ''
 4182        '''
 4183         Bind interface
 4184        '''
 4185        self.egress_filter = egress_filter if egress_filter is not None else ''
 4186        '''
 4187         A filter applied to the routing logic to pin datasource to nodes.
 4188        '''
 4189        self.healthy = healthy if healthy is not None else False
 4190        '''
 4191         True if the datasource is reachable and the credentials are valid.
 4192        '''
 4193        self.hostname = hostname if hostname is not None else ''
 4194        self.id = id if id is not None else ''
 4195        '''
 4196         Unique identifier of the Resource.
 4197        '''
 4198        self.name = name if name is not None else ''
 4199        '''
 4200         Unique human-readable name of the Resource.
 4201        '''
 4202        self.password = password if password is not None else ''
 4203        self.port = port if port is not None else 0
 4204        self.port_override = port_override if port_override is not None else 0
 4205        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4206        '''
 4207         ID of the secret store containing credentials for this resource, if any.
 4208        '''
 4209        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4210        '''
 4211         Tags is a map of key, value pairs.
 4212        '''
 4213        self.username = username if username is not None else ''
 4214
 4215    def __repr__(self):
 4216        return '<sdm.Druid ' + \
 4217            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4218            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4219            'healthy: ' + repr(self.healthy) + ' ' +\
 4220            'hostname: ' + repr(self.hostname) + ' ' +\
 4221            'id: ' + repr(self.id) + ' ' +\
 4222            'name: ' + repr(self.name) + ' ' +\
 4223            'password: ' + repr(self.password) + ' ' +\
 4224            'port: ' + repr(self.port) + ' ' +\
 4225            'port_override: ' + repr(self.port_override) + ' ' +\
 4226            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4227            'tags: ' + repr(self.tags) + ' ' +\
 4228            'username: ' + repr(self.username) + ' ' +\
 4229            '>'
 4230
 4231    def to_dict(self):
 4232        return {
 4233            'bind_interface': self.bind_interface,
 4234            'egress_filter': self.egress_filter,
 4235            'healthy': self.healthy,
 4236            'hostname': self.hostname,
 4237            'id': self.id,
 4238            'name': self.name,
 4239            'password': self.password,
 4240            'port': self.port,
 4241            'port_override': self.port_override,
 4242            'secret_store_id': self.secret_store_id,
 4243            'tags': self.tags,
 4244            'username': self.username,
 4245        }
 4246
 4247    @classmethod
 4248    def from_dict(cls, d):
 4249        return cls(
 4250            bind_interface=d.get('bind_interface'),
 4251            egress_filter=d.get('egress_filter'),
 4252            healthy=d.get('healthy'),
 4253            hostname=d.get('hostname'),
 4254            id=d.get('id'),
 4255            name=d.get('name'),
 4256            password=d.get('password'),
 4257            port=d.get('port'),
 4258            port_override=d.get('port_override'),
 4259            secret_store_id=d.get('secret_store_id'),
 4260            tags=d.get('tags'),
 4261            username=d.get('username'),
 4262        )
 4263
 4264
 4265class DynamoDB:
 4266    __slots__ = [
 4267        'access_key',
 4268        'bind_interface',
 4269        'egress_filter',
 4270        'endpoint',
 4271        'healthy',
 4272        'id',
 4273        'name',
 4274        'port_override',
 4275        'region',
 4276        'role_arn',
 4277        'role_external_id',
 4278        'secret_access_key',
 4279        'secret_store_id',
 4280        'tags',
 4281    ]
 4282
 4283    def __init__(
 4284        self,
 4285        access_key=None,
 4286        bind_interface=None,
 4287        egress_filter=None,
 4288        endpoint=None,
 4289        healthy=None,
 4290        id=None,
 4291        name=None,
 4292        port_override=None,
 4293        region=None,
 4294        role_arn=None,
 4295        role_external_id=None,
 4296        secret_access_key=None,
 4297        secret_store_id=None,
 4298        tags=None,
 4299    ):
 4300        self.access_key = access_key if access_key is not None else ''
 4301        self.bind_interface = bind_interface if bind_interface is not None else ''
 4302        '''
 4303         Bind interface
 4304        '''
 4305        self.egress_filter = egress_filter if egress_filter is not None else ''
 4306        '''
 4307         A filter applied to the routing logic to pin datasource to nodes.
 4308        '''
 4309        self.endpoint = endpoint if endpoint is not None else ''
 4310        self.healthy = healthy if healthy is not None else False
 4311        '''
 4312         True if the datasource is reachable and the credentials are valid.
 4313        '''
 4314        self.id = id if id is not None else ''
 4315        '''
 4316         Unique identifier of the Resource.
 4317        '''
 4318        self.name = name if name is not None else ''
 4319        '''
 4320         Unique human-readable name of the Resource.
 4321        '''
 4322        self.port_override = port_override if port_override is not None else 0
 4323        self.region = region if region is not None else ''
 4324        self.role_arn = role_arn if role_arn is not None else ''
 4325        self.role_external_id = role_external_id if role_external_id is not None else ''
 4326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4327        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4328        '''
 4329         ID of the secret store containing credentials for this resource, if any.
 4330        '''
 4331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4332        '''
 4333         Tags is a map of key, value pairs.
 4334        '''
 4335
 4336    def __repr__(self):
 4337        return '<sdm.DynamoDB ' + \
 4338            'access_key: ' + repr(self.access_key) + ' ' +\
 4339            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4340            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4341            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4342            'healthy: ' + repr(self.healthy) + ' ' +\
 4343            'id: ' + repr(self.id) + ' ' +\
 4344            'name: ' + repr(self.name) + ' ' +\
 4345            'port_override: ' + repr(self.port_override) + ' ' +\
 4346            'region: ' + repr(self.region) + ' ' +\
 4347            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4348            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4349            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4350            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4351            'tags: ' + repr(self.tags) + ' ' +\
 4352            '>'
 4353
 4354    def to_dict(self):
 4355        return {
 4356            'access_key': self.access_key,
 4357            'bind_interface': self.bind_interface,
 4358            'egress_filter': self.egress_filter,
 4359            'endpoint': self.endpoint,
 4360            'healthy': self.healthy,
 4361            'id': self.id,
 4362            'name': self.name,
 4363            'port_override': self.port_override,
 4364            'region': self.region,
 4365            'role_arn': self.role_arn,
 4366            'role_external_id': self.role_external_id,
 4367            'secret_access_key': self.secret_access_key,
 4368            'secret_store_id': self.secret_store_id,
 4369            'tags': self.tags,
 4370        }
 4371
 4372    @classmethod
 4373    def from_dict(cls, d):
 4374        return cls(
 4375            access_key=d.get('access_key'),
 4376            bind_interface=d.get('bind_interface'),
 4377            egress_filter=d.get('egress_filter'),
 4378            endpoint=d.get('endpoint'),
 4379            healthy=d.get('healthy'),
 4380            id=d.get('id'),
 4381            name=d.get('name'),
 4382            port_override=d.get('port_override'),
 4383            region=d.get('region'),
 4384            role_arn=d.get('role_arn'),
 4385            role_external_id=d.get('role_external_id'),
 4386            secret_access_key=d.get('secret_access_key'),
 4387            secret_store_id=d.get('secret_store_id'),
 4388            tags=d.get('tags'),
 4389        )
 4390
 4391
 4392class Elastic:
 4393    __slots__ = [
 4394        'bind_interface',
 4395        'egress_filter',
 4396        'healthy',
 4397        'hostname',
 4398        'id',
 4399        'name',
 4400        'password',
 4401        'port',
 4402        'port_override',
 4403        'secret_store_id',
 4404        'tags',
 4405        'tls_required',
 4406        'username',
 4407    ]
 4408
 4409    def __init__(
 4410        self,
 4411        bind_interface=None,
 4412        egress_filter=None,
 4413        healthy=None,
 4414        hostname=None,
 4415        id=None,
 4416        name=None,
 4417        password=None,
 4418        port=None,
 4419        port_override=None,
 4420        secret_store_id=None,
 4421        tags=None,
 4422        tls_required=None,
 4423        username=None,
 4424    ):
 4425        self.bind_interface = bind_interface if bind_interface is not None else ''
 4426        '''
 4427         Bind interface
 4428        '''
 4429        self.egress_filter = egress_filter if egress_filter is not None else ''
 4430        '''
 4431         A filter applied to the routing logic to pin datasource to nodes.
 4432        '''
 4433        self.healthy = healthy if healthy is not None else False
 4434        '''
 4435         True if the datasource is reachable and the credentials are valid.
 4436        '''
 4437        self.hostname = hostname if hostname is not None else ''
 4438        self.id = id if id is not None else ''
 4439        '''
 4440         Unique identifier of the Resource.
 4441        '''
 4442        self.name = name if name is not None else ''
 4443        '''
 4444         Unique human-readable name of the Resource.
 4445        '''
 4446        self.password = password if password is not None else ''
 4447        self.port = port if port is not None else 0
 4448        self.port_override = port_override if port_override is not None else 0
 4449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4450        '''
 4451         ID of the secret store containing credentials for this resource, if any.
 4452        '''
 4453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4454        '''
 4455         Tags is a map of key, value pairs.
 4456        '''
 4457        self.tls_required = tls_required if tls_required is not None else False
 4458        self.username = username if username is not None else ''
 4459
 4460    def __repr__(self):
 4461        return '<sdm.Elastic ' + \
 4462            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4463            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4464            'healthy: ' + repr(self.healthy) + ' ' +\
 4465            'hostname: ' + repr(self.hostname) + ' ' +\
 4466            'id: ' + repr(self.id) + ' ' +\
 4467            'name: ' + repr(self.name) + ' ' +\
 4468            'password: ' + repr(self.password) + ' ' +\
 4469            'port: ' + repr(self.port) + ' ' +\
 4470            'port_override: ' + repr(self.port_override) + ' ' +\
 4471            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4472            'tags: ' + repr(self.tags) + ' ' +\
 4473            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4474            'username: ' + repr(self.username) + ' ' +\
 4475            '>'
 4476
 4477    def to_dict(self):
 4478        return {
 4479            'bind_interface': self.bind_interface,
 4480            'egress_filter': self.egress_filter,
 4481            'healthy': self.healthy,
 4482            'hostname': self.hostname,
 4483            'id': self.id,
 4484            'name': self.name,
 4485            'password': self.password,
 4486            'port': self.port,
 4487            'port_override': self.port_override,
 4488            'secret_store_id': self.secret_store_id,
 4489            'tags': self.tags,
 4490            'tls_required': self.tls_required,
 4491            'username': self.username,
 4492        }
 4493
 4494    @classmethod
 4495    def from_dict(cls, d):
 4496        return cls(
 4497            bind_interface=d.get('bind_interface'),
 4498            egress_filter=d.get('egress_filter'),
 4499            healthy=d.get('healthy'),
 4500            hostname=d.get('hostname'),
 4501            id=d.get('id'),
 4502            name=d.get('name'),
 4503            password=d.get('password'),
 4504            port=d.get('port'),
 4505            port_override=d.get('port_override'),
 4506            secret_store_id=d.get('secret_store_id'),
 4507            tags=d.get('tags'),
 4508            tls_required=d.get('tls_required'),
 4509            username=d.get('username'),
 4510        )
 4511
 4512
 4513class ElasticacheRedis:
 4514    __slots__ = [
 4515        'bind_interface',
 4516        'egress_filter',
 4517        'healthy',
 4518        'hostname',
 4519        'id',
 4520        'name',
 4521        'password',
 4522        'port',
 4523        'port_override',
 4524        'secret_store_id',
 4525        'tags',
 4526        'tls_required',
 4527    ]
 4528
 4529    def __init__(
 4530        self,
 4531        bind_interface=None,
 4532        egress_filter=None,
 4533        healthy=None,
 4534        hostname=None,
 4535        id=None,
 4536        name=None,
 4537        password=None,
 4538        port=None,
 4539        port_override=None,
 4540        secret_store_id=None,
 4541        tags=None,
 4542        tls_required=None,
 4543    ):
 4544        self.bind_interface = bind_interface if bind_interface is not None else ''
 4545        '''
 4546         Bind interface
 4547        '''
 4548        self.egress_filter = egress_filter if egress_filter is not None else ''
 4549        '''
 4550         A filter applied to the routing logic to pin datasource to nodes.
 4551        '''
 4552        self.healthy = healthy if healthy is not None else False
 4553        '''
 4554         True if the datasource is reachable and the credentials are valid.
 4555        '''
 4556        self.hostname = hostname if hostname is not None else ''
 4557        self.id = id if id is not None else ''
 4558        '''
 4559         Unique identifier of the Resource.
 4560        '''
 4561        self.name = name if name is not None else ''
 4562        '''
 4563         Unique human-readable name of the Resource.
 4564        '''
 4565        self.password = password if password is not None else ''
 4566        self.port = port if port is not None else 0
 4567        self.port_override = port_override if port_override is not None else 0
 4568        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4569        '''
 4570         ID of the secret store containing credentials for this resource, if any.
 4571        '''
 4572        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4573        '''
 4574         Tags is a map of key, value pairs.
 4575        '''
 4576        self.tls_required = tls_required if tls_required is not None else False
 4577
 4578    def __repr__(self):
 4579        return '<sdm.ElasticacheRedis ' + \
 4580            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4581            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4582            'healthy: ' + repr(self.healthy) + ' ' +\
 4583            'hostname: ' + repr(self.hostname) + ' ' +\
 4584            'id: ' + repr(self.id) + ' ' +\
 4585            'name: ' + repr(self.name) + ' ' +\
 4586            'password: ' + repr(self.password) + ' ' +\
 4587            'port: ' + repr(self.port) + ' ' +\
 4588            'port_override: ' + repr(self.port_override) + ' ' +\
 4589            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4590            'tags: ' + repr(self.tags) + ' ' +\
 4591            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4592            '>'
 4593
 4594    def to_dict(self):
 4595        return {
 4596            'bind_interface': self.bind_interface,
 4597            'egress_filter': self.egress_filter,
 4598            'healthy': self.healthy,
 4599            'hostname': self.hostname,
 4600            'id': self.id,
 4601            'name': self.name,
 4602            'password': self.password,
 4603            'port': self.port,
 4604            'port_override': self.port_override,
 4605            'secret_store_id': self.secret_store_id,
 4606            'tags': self.tags,
 4607            'tls_required': self.tls_required,
 4608        }
 4609
 4610    @classmethod
 4611    def from_dict(cls, d):
 4612        return cls(
 4613            bind_interface=d.get('bind_interface'),
 4614            egress_filter=d.get('egress_filter'),
 4615            healthy=d.get('healthy'),
 4616            hostname=d.get('hostname'),
 4617            id=d.get('id'),
 4618            name=d.get('name'),
 4619            password=d.get('password'),
 4620            port=d.get('port'),
 4621            port_override=d.get('port_override'),
 4622            secret_store_id=d.get('secret_store_id'),
 4623            tags=d.get('tags'),
 4624            tls_required=d.get('tls_required'),
 4625        )
 4626
 4627
 4628class EnvStore:
 4629    '''
 4630    EnvStore is currently unstable, and its API may change, or it may be removed,
 4631    without a major version bump.
 4632    '''
 4633    __slots__ = [
 4634        'id',
 4635        'name',
 4636        'tags',
 4637    ]
 4638
 4639    def __init__(
 4640        self,
 4641        id=None,
 4642        name=None,
 4643        tags=None,
 4644    ):
 4645        self.id = id if id is not None else ''
 4646        '''
 4647         Unique identifier of the SecretStore.
 4648        '''
 4649        self.name = name if name is not None else ''
 4650        '''
 4651         Unique human-readable name of the SecretStore.
 4652        '''
 4653        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4654        '''
 4655         Tags is a map of key, value pairs.
 4656        '''
 4657
 4658    def __repr__(self):
 4659        return '<sdm.EnvStore ' + \
 4660            'id: ' + repr(self.id) + ' ' +\
 4661            'name: ' + repr(self.name) + ' ' +\
 4662            'tags: ' + repr(self.tags) + ' ' +\
 4663            '>'
 4664
 4665    def to_dict(self):
 4666        return {
 4667            'id': self.id,
 4668            'name': self.name,
 4669            'tags': self.tags,
 4670        }
 4671
 4672    @classmethod
 4673    def from_dict(cls, d):
 4674        return cls(
 4675            id=d.get('id'),
 4676            name=d.get('name'),
 4677            tags=d.get('tags'),
 4678        )
 4679
 4680
 4681class GCP:
 4682    __slots__ = [
 4683        'bind_interface',
 4684        'egress_filter',
 4685        'healthy',
 4686        'id',
 4687        'keyfile',
 4688        'name',
 4689        'scopes',
 4690        'secret_store_id',
 4691        'tags',
 4692    ]
 4693
 4694    def __init__(
 4695        self,
 4696        bind_interface=None,
 4697        egress_filter=None,
 4698        healthy=None,
 4699        id=None,
 4700        keyfile=None,
 4701        name=None,
 4702        scopes=None,
 4703        secret_store_id=None,
 4704        tags=None,
 4705    ):
 4706        self.bind_interface = bind_interface if bind_interface is not None else ''
 4707        '''
 4708         Bind interface
 4709        '''
 4710        self.egress_filter = egress_filter if egress_filter is not None else ''
 4711        '''
 4712         A filter applied to the routing logic to pin datasource to nodes.
 4713        '''
 4714        self.healthy = healthy if healthy is not None else False
 4715        '''
 4716         True if the datasource is reachable and the credentials are valid.
 4717        '''
 4718        self.id = id if id is not None else ''
 4719        '''
 4720         Unique identifier of the Resource.
 4721        '''
 4722        self.keyfile = keyfile if keyfile is not None else ''
 4723        self.name = name if name is not None else ''
 4724        '''
 4725         Unique human-readable name of the Resource.
 4726        '''
 4727        self.scopes = scopes if scopes is not None else ''
 4728        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4729        '''
 4730         ID of the secret store containing credentials for this resource, if any.
 4731        '''
 4732        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4733        '''
 4734         Tags is a map of key, value pairs.
 4735        '''
 4736
 4737    def __repr__(self):
 4738        return '<sdm.GCP ' + \
 4739            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4740            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4741            'healthy: ' + repr(self.healthy) + ' ' +\
 4742            'id: ' + repr(self.id) + ' ' +\
 4743            'keyfile: ' + repr(self.keyfile) + ' ' +\
 4744            'name: ' + repr(self.name) + ' ' +\
 4745            'scopes: ' + repr(self.scopes) + ' ' +\
 4746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4747            'tags: ' + repr(self.tags) + ' ' +\
 4748            '>'
 4749
 4750    def to_dict(self):
 4751        return {
 4752            'bind_interface': self.bind_interface,
 4753            'egress_filter': self.egress_filter,
 4754            'healthy': self.healthy,
 4755            'id': self.id,
 4756            'keyfile': self.keyfile,
 4757            'name': self.name,
 4758            'scopes': self.scopes,
 4759            'secret_store_id': self.secret_store_id,
 4760            'tags': self.tags,
 4761        }
 4762
 4763    @classmethod
 4764    def from_dict(cls, d):
 4765        return cls(
 4766            bind_interface=d.get('bind_interface'),
 4767            egress_filter=d.get('egress_filter'),
 4768            healthy=d.get('healthy'),
 4769            id=d.get('id'),
 4770            keyfile=d.get('keyfile'),
 4771            name=d.get('name'),
 4772            scopes=d.get('scopes'),
 4773            secret_store_id=d.get('secret_store_id'),
 4774            tags=d.get('tags'),
 4775        )
 4776
 4777
 4778class GCPStore:
 4779    __slots__ = [
 4780        'id',
 4781        'name',
 4782        'projectid',
 4783        'tags',
 4784    ]
 4785
 4786    def __init__(
 4787        self,
 4788        id=None,
 4789        name=None,
 4790        projectid=None,
 4791        tags=None,
 4792    ):
 4793        self.id = id if id is not None else ''
 4794        '''
 4795         Unique identifier of the SecretStore.
 4796        '''
 4797        self.name = name if name is not None else ''
 4798        '''
 4799         Unique human-readable name of the SecretStore.
 4800        '''
 4801        self.projectid = projectid if projectid is not None else ''
 4802        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4803        '''
 4804         Tags is a map of key, value pairs.
 4805        '''
 4806
 4807    def __repr__(self):
 4808        return '<sdm.GCPStore ' + \
 4809            'id: ' + repr(self.id) + ' ' +\
 4810            'name: ' + repr(self.name) + ' ' +\
 4811            'projectid: ' + repr(self.projectid) + ' ' +\
 4812            'tags: ' + repr(self.tags) + ' ' +\
 4813            '>'
 4814
 4815    def to_dict(self):
 4816        return {
 4817            'id': self.id,
 4818            'name': self.name,
 4819            'projectid': self.projectid,
 4820            'tags': self.tags,
 4821        }
 4822
 4823    @classmethod
 4824    def from_dict(cls, d):
 4825        return cls(
 4826            id=d.get('id'),
 4827            name=d.get('name'),
 4828            projectid=d.get('projectid'),
 4829            tags=d.get('tags'),
 4830        )
 4831
 4832
 4833class Gateway:
 4834    '''
 4835         Gateway represents a StrongDM CLI installation running in gateway mode.
 4836    '''
 4837    __slots__ = [
 4838        'bind_address',
 4839        'gateway_filter',
 4840        'id',
 4841        'listen_address',
 4842        'name',
 4843        'state',
 4844        'tags',
 4845    ]
 4846
 4847    def __init__(
 4848        self,
 4849        bind_address=None,
 4850        gateway_filter=None,
 4851        id=None,
 4852        listen_address=None,
 4853        name=None,
 4854        state=None,
 4855        tags=None,
 4856    ):
 4857        self.bind_address = bind_address if bind_address is not None else ''
 4858        '''
 4859         The hostname/port tuple which the gateway daemon will bind to.
 4860         If not provided on create, set to "0.0.0.0:listen_address_port".
 4861        '''
 4862        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 4863        '''
 4864         GatewayFilter can be used to restrict the peering between relays and
 4865         gateways.
 4866        '''
 4867        self.id = id if id is not None else ''
 4868        '''
 4869         Unique identifier of the Gateway.
 4870        '''
 4871        self.listen_address = listen_address if listen_address is not None else ''
 4872        '''
 4873         The public hostname/port tuple at which the gateway will be accessible to clients.
 4874        '''
 4875        self.name = name if name is not None else ''
 4876        '''
 4877         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 4878        '''
 4879        self.state = state if state is not None else ''
 4880        '''
 4881         The current state of the gateway. One of: "new", "verifying_restart",
 4882         "restarting", "started", "stopped", "dead", "unknown"
 4883        '''
 4884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4885        '''
 4886         Tags is a map of key, value pairs.
 4887        '''
 4888
 4889    def __repr__(self):
 4890        return '<sdm.Gateway ' + \
 4891            'bind_address: ' + repr(self.bind_address) + ' ' +\
 4892            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 4893            'id: ' + repr(self.id) + ' ' +\
 4894            'listen_address: ' + repr(self.listen_address) + ' ' +\
 4895            'name: ' + repr(self.name) + ' ' +\
 4896            'state: ' + repr(self.state) + ' ' +\
 4897            'tags: ' + repr(self.tags) + ' ' +\
 4898            '>'
 4899
 4900    def to_dict(self):
 4901        return {
 4902            'bind_address': self.bind_address,
 4903            'gateway_filter': self.gateway_filter,
 4904            'id': self.id,
 4905            'listen_address': self.listen_address,
 4906            'name': self.name,
 4907            'state': self.state,
 4908            'tags': self.tags,
 4909        }
 4910
 4911    @classmethod
 4912    def from_dict(cls, d):
 4913        return cls(
 4914            bind_address=d.get('bind_address'),
 4915            gateway_filter=d.get('gateway_filter'),
 4916            id=d.get('id'),
 4917            listen_address=d.get('listen_address'),
 4918            name=d.get('name'),
 4919            state=d.get('state'),
 4920            tags=d.get('tags'),
 4921        )
 4922
 4923
 4924class GetResponseMetadata:
 4925    '''
 4926         GetResponseMetadata is reserved for future use.
 4927    '''
 4928    __slots__ = []
 4929
 4930    def __init__(self, ):
 4931        pass
 4932
 4933    def __repr__(self):
 4934        return '<sdm.GetResponseMetadata ' + \
 4935            '>'
 4936
 4937    def to_dict(self):
 4938        return {}
 4939
 4940    @classmethod
 4941    def from_dict(cls, d):
 4942        return cls()
 4943
 4944
 4945class GoogleGKE:
 4946    __slots__ = [
 4947        'bind_interface',
 4948        'certificate_authority',
 4949        'egress_filter',
 4950        'endpoint',
 4951        'healthcheck_namespace',
 4952        'healthy',
 4953        'id',
 4954        'name',
 4955        'remote_identity_group_id',
 4956        'remote_identity_healthcheck_username',
 4957        'secret_store_id',
 4958        'service_account_key',
 4959        'tags',
 4960    ]
 4961
 4962    def __init__(
 4963        self,
 4964        bind_interface=None,
 4965        certificate_authority=None,
 4966        egress_filter=None,
 4967        endpoint=None,
 4968        healthcheck_namespace=None,
 4969        healthy=None,
 4970        id=None,
 4971        name=None,
 4972        remote_identity_group_id=None,
 4973        remote_identity_healthcheck_username=None,
 4974        secret_store_id=None,
 4975        service_account_key=None,
 4976        tags=None,
 4977    ):
 4978        self.bind_interface = bind_interface if bind_interface is not None else ''
 4979        '''
 4980         Bind interface
 4981        '''
 4982        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 4983        self.egress_filter = egress_filter if egress_filter is not None else ''
 4984        '''
 4985         A filter applied to the routing logic to pin datasource to nodes.
 4986        '''
 4987        self.endpoint = endpoint if endpoint is not None else ''
 4988        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 4989        '''
 4990         The path used to check the health of your connection.  Defaults to `default`.
 4991        '''
 4992        self.healthy = healthy if healthy is not None else False
 4993        '''
 4994         True if the datasource is reachable and the credentials are valid.
 4995        '''
 4996        self.id = id if id is not None else ''
 4997        '''
 4998         Unique identifier of the Resource.
 4999        '''
 5000        self.name = name if name is not None else ''
 5001        '''
 5002         Unique human-readable name of the Resource.
 5003        '''
 5004        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5005        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5007        '''
 5008         ID of the secret store containing credentials for this resource, if any.
 5009        '''
 5010        self.service_account_key = service_account_key if service_account_key is not None else ''
 5011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5012        '''
 5013         Tags is a map of key, value pairs.
 5014        '''
 5015
 5016    def __repr__(self):
 5017        return '<sdm.GoogleGKE ' + \
 5018            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5019            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5020            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5021            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5022            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5023            'healthy: ' + repr(self.healthy) + ' ' +\
 5024            'id: ' + repr(self.id) + ' ' +\
 5025            'name: ' + repr(self.name) + ' ' +\
 5026            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5027            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5029            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5030            'tags: ' + repr(self.tags) + ' ' +\
 5031            '>'
 5032
 5033    def to_dict(self):
 5034        return {
 5035            'bind_interface': self.bind_interface,
 5036            'certificate_authority': self.certificate_authority,
 5037            'egress_filter': self.egress_filter,
 5038            'endpoint': self.endpoint,
 5039            'healthcheck_namespace': self.healthcheck_namespace,
 5040            'healthy': self.healthy,
 5041            'id': self.id,
 5042            'name': self.name,
 5043            'remote_identity_group_id': self.remote_identity_group_id,
 5044            'remote_identity_healthcheck_username':
 5045            self.remote_identity_healthcheck_username,
 5046            'secret_store_id': self.secret_store_id,
 5047            'service_account_key': self.service_account_key,
 5048            'tags': self.tags,
 5049        }
 5050
 5051    @classmethod
 5052    def from_dict(cls, d):
 5053        return cls(
 5054            bind_interface=d.get('bind_interface'),
 5055            certificate_authority=d.get('certificate_authority'),
 5056            egress_filter=d.get('egress_filter'),
 5057            endpoint=d.get('endpoint'),
 5058            healthcheck_namespace=d.get('healthcheck_namespace'),
 5059            healthy=d.get('healthy'),
 5060            id=d.get('id'),
 5061            name=d.get('name'),
 5062            remote_identity_group_id=d.get('remote_identity_group_id'),
 5063            remote_identity_healthcheck_username=d.get(
 5064                'remote_identity_healthcheck_username'),
 5065            secret_store_id=d.get('secret_store_id'),
 5066            service_account_key=d.get('service_account_key'),
 5067            tags=d.get('tags'),
 5068        )
 5069
 5070
 5071class GoogleGKEUserImpersonation:
 5072    __slots__ = [
 5073        'bind_interface',
 5074        'certificate_authority',
 5075        'egress_filter',
 5076        'endpoint',
 5077        'healthcheck_namespace',
 5078        'healthy',
 5079        'id',
 5080        'name',
 5081        'secret_store_id',
 5082        'service_account_key',
 5083        'tags',
 5084    ]
 5085
 5086    def __init__(
 5087        self,
 5088        bind_interface=None,
 5089        certificate_authority=None,
 5090        egress_filter=None,
 5091        endpoint=None,
 5092        healthcheck_namespace=None,
 5093        healthy=None,
 5094        id=None,
 5095        name=None,
 5096        secret_store_id=None,
 5097        service_account_key=None,
 5098        tags=None,
 5099    ):
 5100        self.bind_interface = bind_interface if bind_interface is not None else ''
 5101        '''
 5102         Bind interface
 5103        '''
 5104        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5105        self.egress_filter = egress_filter if egress_filter is not None else ''
 5106        '''
 5107         A filter applied to the routing logic to pin datasource to nodes.
 5108        '''
 5109        self.endpoint = endpoint if endpoint is not None else ''
 5110        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5111        '''
 5112         The path used to check the health of your connection.  Defaults to `default`.
 5113        '''
 5114        self.healthy = healthy if healthy is not None else False
 5115        '''
 5116         True if the datasource is reachable and the credentials are valid.
 5117        '''
 5118        self.id = id if id is not None else ''
 5119        '''
 5120         Unique identifier of the Resource.
 5121        '''
 5122        self.name = name if name is not None else ''
 5123        '''
 5124         Unique human-readable name of the Resource.
 5125        '''
 5126        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5127        '''
 5128         ID of the secret store containing credentials for this resource, if any.
 5129        '''
 5130        self.service_account_key = service_account_key if service_account_key is not None else ''
 5131        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5132        '''
 5133         Tags is a map of key, value pairs.
 5134        '''
 5135
 5136    def __repr__(self):
 5137        return '<sdm.GoogleGKEUserImpersonation ' + \
 5138            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5139            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5140            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5141            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5142            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5143            'healthy: ' + repr(self.healthy) + ' ' +\
 5144            'id: ' + repr(self.id) + ' ' +\
 5145            'name: ' + repr(self.name) + ' ' +\
 5146            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5147            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5148            'tags: ' + repr(self.tags) + ' ' +\
 5149            '>'
 5150
 5151    def to_dict(self):
 5152        return {
 5153            'bind_interface': self.bind_interface,
 5154            'certificate_authority': self.certificate_authority,
 5155            'egress_filter': self.egress_filter,
 5156            'endpoint': self.endpoint,
 5157            'healthcheck_namespace': self.healthcheck_namespace,
 5158            'healthy': self.healthy,
 5159            'id': self.id,
 5160            'name': self.name,
 5161            'secret_store_id': self.secret_store_id,
 5162            'service_account_key': self.service_account_key,
 5163            'tags': self.tags,
 5164        }
 5165
 5166    @classmethod
 5167    def from_dict(cls, d):
 5168        return cls(
 5169            bind_interface=d.get('bind_interface'),
 5170            certificate_authority=d.get('certificate_authority'),
 5171            egress_filter=d.get('egress_filter'),
 5172            endpoint=d.get('endpoint'),
 5173            healthcheck_namespace=d.get('healthcheck_namespace'),
 5174            healthy=d.get('healthy'),
 5175            id=d.get('id'),
 5176            name=d.get('name'),
 5177            secret_store_id=d.get('secret_store_id'),
 5178            service_account_key=d.get('service_account_key'),
 5179            tags=d.get('tags'),
 5180        )
 5181
 5182
 5183class Greenplum:
 5184    __slots__ = [
 5185        'bind_interface',
 5186        'database',
 5187        'egress_filter',
 5188        'healthy',
 5189        'hostname',
 5190        'id',
 5191        'name',
 5192        'override_database',
 5193        'password',
 5194        'port',
 5195        'port_override',
 5196        'secret_store_id',
 5197        'tags',
 5198        'username',
 5199    ]
 5200
 5201    def __init__(
 5202        self,
 5203        bind_interface=None,
 5204        database=None,
 5205        egress_filter=None,
 5206        healthy=None,
 5207        hostname=None,
 5208        id=None,
 5209        name=None,
 5210        override_database=None,
 5211        password=None,
 5212        port=None,
 5213        port_override=None,
 5214        secret_store_id=None,
 5215        tags=None,
 5216        username=None,
 5217    ):
 5218        self.bind_interface = bind_interface if bind_interface is not None else ''
 5219        '''
 5220         Bind interface
 5221        '''
 5222        self.database = database if database is not None else ''
 5223        self.egress_filter = egress_filter if egress_filter is not None else ''
 5224        '''
 5225         A filter applied to the routing logic to pin datasource to nodes.
 5226        '''
 5227        self.healthy = healthy if healthy is not None else False
 5228        '''
 5229         True if the datasource is reachable and the credentials are valid.
 5230        '''
 5231        self.hostname = hostname if hostname is not None else ''
 5232        self.id = id if id is not None else ''
 5233        '''
 5234         Unique identifier of the Resource.
 5235        '''
 5236        self.name = name if name is not None else ''
 5237        '''
 5238         Unique human-readable name of the Resource.
 5239        '''
 5240        self.override_database = override_database if override_database is not None else False
 5241        self.password = password if password is not None else ''
 5242        self.port = port if port is not None else 0
 5243        self.port_override = port_override if port_override is not None else 0
 5244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5245        '''
 5246         ID of the secret store containing credentials for this resource, if any.
 5247        '''
 5248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5249        '''
 5250         Tags is a map of key, value pairs.
 5251        '''
 5252        self.username = username if username is not None else ''
 5253
 5254    def __repr__(self):
 5255        return '<sdm.Greenplum ' + \
 5256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5257            'database: ' + repr(self.database) + ' ' +\
 5258            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5259            'healthy: ' + repr(self.healthy) + ' ' +\
 5260            'hostname: ' + repr(self.hostname) + ' ' +\
 5261            'id: ' + repr(self.id) + ' ' +\
 5262            'name: ' + repr(self.name) + ' ' +\
 5263            'override_database: ' + repr(self.override_database) + ' ' +\
 5264            'password: ' + repr(self.password) + ' ' +\
 5265            'port: ' + repr(self.port) + ' ' +\
 5266            'port_override: ' + repr(self.port_override) + ' ' +\
 5267            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5268            'tags: ' + repr(self.tags) + ' ' +\
 5269            'username: ' + repr(self.username) + ' ' +\
 5270            '>'
 5271
 5272    def to_dict(self):
 5273        return {
 5274            'bind_interface': self.bind_interface,
 5275            'database': self.database,
 5276            'egress_filter': self.egress_filter,
 5277            'healthy': self.healthy,
 5278            'hostname': self.hostname,
 5279            'id': self.id,
 5280            'name': self.name,
 5281            'override_database': self.override_database,
 5282            'password': self.password,
 5283            'port': self.port,
 5284            'port_override': self.port_override,
 5285            'secret_store_id': self.secret_store_id,
 5286            'tags': self.tags,
 5287            'username': self.username,
 5288        }
 5289
 5290    @classmethod
 5291    def from_dict(cls, d):
 5292        return cls(
 5293            bind_interface=d.get('bind_interface'),
 5294            database=d.get('database'),
 5295            egress_filter=d.get('egress_filter'),
 5296            healthy=d.get('healthy'),
 5297            hostname=d.get('hostname'),
 5298            id=d.get('id'),
 5299            name=d.get('name'),
 5300            override_database=d.get('override_database'),
 5301            password=d.get('password'),
 5302            port=d.get('port'),
 5303            port_override=d.get('port_override'),
 5304            secret_store_id=d.get('secret_store_id'),
 5305            tags=d.get('tags'),
 5306            username=d.get('username'),
 5307        )
 5308
 5309
 5310class HTTPAuth:
 5311    __slots__ = [
 5312        'auth_header',
 5313        'bind_interface',
 5314        'default_path',
 5315        'egress_filter',
 5316        'headers_blacklist',
 5317        'healthcheck_path',
 5318        'healthy',
 5319        'id',
 5320        'name',
 5321        'secret_store_id',
 5322        'subdomain',
 5323        'tags',
 5324        'url',
 5325    ]
 5326
 5327    def __init__(
 5328        self,
 5329        auth_header=None,
 5330        bind_interface=None,
 5331        default_path=None,
 5332        egress_filter=None,
 5333        headers_blacklist=None,
 5334        healthcheck_path=None,
 5335        healthy=None,
 5336        id=None,
 5337        name=None,
 5338        secret_store_id=None,
 5339        subdomain=None,
 5340        tags=None,
 5341        url=None,
 5342    ):
 5343        self.auth_header = auth_header if auth_header is not None else ''
 5344        self.bind_interface = bind_interface if bind_interface is not None else ''
 5345        '''
 5346         Bind interface
 5347        '''
 5348        self.default_path = default_path if default_path is not None else ''
 5349        self.egress_filter = egress_filter if egress_filter is not None else ''
 5350        '''
 5351         A filter applied to the routing logic to pin datasource to nodes.
 5352        '''
 5353        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5354        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5355        self.healthy = healthy if healthy is not None else False
 5356        '''
 5357         True if the datasource is reachable and the credentials are valid.
 5358        '''
 5359        self.id = id if id is not None else ''
 5360        '''
 5361         Unique identifier of the Resource.
 5362        '''
 5363        self.name = name if name is not None else ''
 5364        '''
 5365         Unique human-readable name of the Resource.
 5366        '''
 5367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5368        '''
 5369         ID of the secret store containing credentials for this resource, if any.
 5370        '''
 5371        self.subdomain = subdomain if subdomain is not None else ''
 5372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5373        '''
 5374         Tags is a map of key, value pairs.
 5375        '''
 5376        self.url = url if url is not None else ''
 5377
 5378    def __repr__(self):
 5379        return '<sdm.HTTPAuth ' + \
 5380            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5382            'default_path: ' + repr(self.default_path) + ' ' +\
 5383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5384            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5385            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5386            'healthy: ' + repr(self.healthy) + ' ' +\
 5387            'id: ' + repr(self.id) + ' ' +\
 5388            'name: ' + repr(self.name) + ' ' +\
 5389            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5390            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5391            'tags: ' + repr(self.tags) + ' ' +\
 5392            'url: ' + repr(self.url) + ' ' +\
 5393            '>'
 5394
 5395    def to_dict(self):
 5396        return {
 5397            'auth_header': self.auth_header,
 5398            'bind_interface': self.bind_interface,
 5399            'default_path': self.default_path,
 5400            'egress_filter': self.egress_filter,
 5401            'headers_blacklist': self.headers_blacklist,
 5402            'healthcheck_path': self.healthcheck_path,
 5403            'healthy': self.healthy,
 5404            'id': self.id,
 5405            'name': self.name,
 5406            'secret_store_id': self.secret_store_id,
 5407            'subdomain': self.subdomain,
 5408            'tags': self.tags,
 5409            'url': self.url,
 5410        }
 5411
 5412    @classmethod
 5413    def from_dict(cls, d):
 5414        return cls(
 5415            auth_header=d.get('auth_header'),
 5416            bind_interface=d.get('bind_interface'),
 5417            default_path=d.get('default_path'),
 5418            egress_filter=d.get('egress_filter'),
 5419            headers_blacklist=d.get('headers_blacklist'),
 5420            healthcheck_path=d.get('healthcheck_path'),
 5421            healthy=d.get('healthy'),
 5422            id=d.get('id'),
 5423            name=d.get('name'),
 5424            secret_store_id=d.get('secret_store_id'),
 5425            subdomain=d.get('subdomain'),
 5426            tags=d.get('tags'),
 5427            url=d.get('url'),
 5428        )
 5429
 5430
 5431class HTTPBasicAuth:
 5432    __slots__ = [
 5433        'bind_interface',
 5434        'default_path',
 5435        'egress_filter',
 5436        'headers_blacklist',
 5437        'healthcheck_path',
 5438        'healthy',
 5439        'id',
 5440        'name',
 5441        'password',
 5442        'secret_store_id',
 5443        'subdomain',
 5444        'tags',
 5445        'url',
 5446        'username',
 5447    ]
 5448
 5449    def __init__(
 5450        self,
 5451        bind_interface=None,
 5452        default_path=None,
 5453        egress_filter=None,
 5454        headers_blacklist=None,
 5455        healthcheck_path=None,
 5456        healthy=None,
 5457        id=None,
 5458        name=None,
 5459        password=None,
 5460        secret_store_id=None,
 5461        subdomain=None,
 5462        tags=None,
 5463        url=None,
 5464        username=None,
 5465    ):
 5466        self.bind_interface = bind_interface if bind_interface is not None else ''
 5467        '''
 5468         Bind interface
 5469        '''
 5470        self.default_path = default_path if default_path is not None else ''
 5471        self.egress_filter = egress_filter if egress_filter is not None else ''
 5472        '''
 5473         A filter applied to the routing logic to pin datasource to nodes.
 5474        '''
 5475        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5476        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5477        self.healthy = healthy if healthy is not None else False
 5478        '''
 5479         True if the datasource is reachable and the credentials are valid.
 5480        '''
 5481        self.id = id if id is not None else ''
 5482        '''
 5483         Unique identifier of the Resource.
 5484        '''
 5485        self.name = name if name is not None else ''
 5486        '''
 5487         Unique human-readable name of the Resource.
 5488        '''
 5489        self.password = password if password is not None else ''
 5490        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5491        '''
 5492         ID of the secret store containing credentials for this resource, if any.
 5493        '''
 5494        self.subdomain = subdomain if subdomain is not None else ''
 5495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5496        '''
 5497         Tags is a map of key, value pairs.
 5498        '''
 5499        self.url = url if url is not None else ''
 5500        self.username = username if username is not None else ''
 5501
 5502    def __repr__(self):
 5503        return '<sdm.HTTPBasicAuth ' + \
 5504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5505            'default_path: ' + repr(self.default_path) + ' ' +\
 5506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5507            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5508            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5509            'healthy: ' + repr(self.healthy) + ' ' +\
 5510            'id: ' + repr(self.id) + ' ' +\
 5511            'name: ' + repr(self.name) + ' ' +\
 5512            'password: ' + repr(self.password) + ' ' +\
 5513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5514            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5515            'tags: ' + repr(self.tags) + ' ' +\
 5516            'url: ' + repr(self.url) + ' ' +\
 5517            'username: ' + repr(self.username) + ' ' +\
 5518            '>'
 5519
 5520    def to_dict(self):
 5521        return {
 5522            'bind_interface': self.bind_interface,
 5523            'default_path': self.default_path,
 5524            'egress_filter': self.egress_filter,
 5525            'headers_blacklist': self.headers_blacklist,
 5526            'healthcheck_path': self.healthcheck_path,
 5527            'healthy': self.healthy,
 5528            'id': self.id,
 5529            'name': self.name,
 5530            'password': self.password,
 5531            'secret_store_id': self.secret_store_id,
 5532            'subdomain': self.subdomain,
 5533            'tags': self.tags,
 5534            'url': self.url,
 5535            'username': self.username,
 5536        }
 5537
 5538    @classmethod
 5539    def from_dict(cls, d):
 5540        return cls(
 5541            bind_interface=d.get('bind_interface'),
 5542            default_path=d.get('default_path'),
 5543            egress_filter=d.get('egress_filter'),
 5544            headers_blacklist=d.get('headers_blacklist'),
 5545            healthcheck_path=d.get('healthcheck_path'),
 5546            healthy=d.get('healthy'),
 5547            id=d.get('id'),
 5548            name=d.get('name'),
 5549            password=d.get('password'),
 5550            secret_store_id=d.get('secret_store_id'),
 5551            subdomain=d.get('subdomain'),
 5552            tags=d.get('tags'),
 5553            url=d.get('url'),
 5554            username=d.get('username'),
 5555        )
 5556
 5557
 5558class HTTPNoAuth:
 5559    __slots__ = [
 5560        'bind_interface',
 5561        'default_path',
 5562        'egress_filter',
 5563        'headers_blacklist',
 5564        'healthcheck_path',
 5565        'healthy',
 5566        'id',
 5567        'name',
 5568        'secret_store_id',
 5569        'subdomain',
 5570        'tags',
 5571        'url',
 5572    ]
 5573
 5574    def __init__(
 5575        self,
 5576        bind_interface=None,
 5577        default_path=None,
 5578        egress_filter=None,
 5579        headers_blacklist=None,
 5580        healthcheck_path=None,
 5581        healthy=None,
 5582        id=None,
 5583        name=None,
 5584        secret_store_id=None,
 5585        subdomain=None,
 5586        tags=None,
 5587        url=None,
 5588    ):
 5589        self.bind_interface = bind_interface if bind_interface is not None else ''
 5590        '''
 5591         Bind interface
 5592        '''
 5593        self.default_path = default_path if default_path is not None else ''
 5594        self.egress_filter = egress_filter if egress_filter is not None else ''
 5595        '''
 5596         A filter applied to the routing logic to pin datasource to nodes.
 5597        '''
 5598        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5599        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5600        self.healthy = healthy if healthy is not None else False
 5601        '''
 5602         True if the datasource is reachable and the credentials are valid.
 5603        '''
 5604        self.id = id if id is not None else ''
 5605        '''
 5606         Unique identifier of the Resource.
 5607        '''
 5608        self.name = name if name is not None else ''
 5609        '''
 5610         Unique human-readable name of the Resource.
 5611        '''
 5612        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5613        '''
 5614         ID of the secret store containing credentials for this resource, if any.
 5615        '''
 5616        self.subdomain = subdomain if subdomain is not None else ''
 5617        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5618        '''
 5619         Tags is a map of key, value pairs.
 5620        '''
 5621        self.url = url if url is not None else ''
 5622
 5623    def __repr__(self):
 5624        return '<sdm.HTTPNoAuth ' + \
 5625            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5626            'default_path: ' + repr(self.default_path) + ' ' +\
 5627            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5628            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5629            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5630            'healthy: ' + repr(self.healthy) + ' ' +\
 5631            'id: ' + repr(self.id) + ' ' +\
 5632            'name: ' + repr(self.name) + ' ' +\
 5633            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5634            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5635            'tags: ' + repr(self.tags) + ' ' +\
 5636            'url: ' + repr(self.url) + ' ' +\
 5637            '>'
 5638
 5639    def to_dict(self):
 5640        return {
 5641            'bind_interface': self.bind_interface,
 5642            'default_path': self.default_path,
 5643            'egress_filter': self.egress_filter,
 5644            'headers_blacklist': self.headers_blacklist,
 5645            'healthcheck_path': self.healthcheck_path,
 5646            'healthy': self.healthy,
 5647            'id': self.id,
 5648            'name': self.name,
 5649            'secret_store_id': self.secret_store_id,
 5650            'subdomain': self.subdomain,
 5651            'tags': self.tags,
 5652            'url': self.url,
 5653        }
 5654
 5655    @classmethod
 5656    def from_dict(cls, d):
 5657        return cls(
 5658            bind_interface=d.get('bind_interface'),
 5659            default_path=d.get('default_path'),
 5660            egress_filter=d.get('egress_filter'),
 5661            headers_blacklist=d.get('headers_blacklist'),
 5662            healthcheck_path=d.get('healthcheck_path'),
 5663            healthy=d.get('healthy'),
 5664            id=d.get('id'),
 5665            name=d.get('name'),
 5666            secret_store_id=d.get('secret_store_id'),
 5667            subdomain=d.get('subdomain'),
 5668            tags=d.get('tags'),
 5669            url=d.get('url'),
 5670        )
 5671
 5672
 5673class Kubernetes:
 5674    __slots__ = [
 5675        'bind_interface',
 5676        'certificate_authority',
 5677        'client_certificate',
 5678        'client_key',
 5679        'egress_filter',
 5680        'healthcheck_namespace',
 5681        'healthy',
 5682        'hostname',
 5683        'id',
 5684        'name',
 5685        'port',
 5686        'port_override',
 5687        'remote_identity_group_id',
 5688        'remote_identity_healthcheck_username',
 5689        'secret_store_id',
 5690        'tags',
 5691    ]
 5692
 5693    def __init__(
 5694        self,
 5695        bind_interface=None,
 5696        certificate_authority=None,
 5697        client_certificate=None,
 5698        client_key=None,
 5699        egress_filter=None,
 5700        healthcheck_namespace=None,
 5701        healthy=None,
 5702        hostname=None,
 5703        id=None,
 5704        name=None,
 5705        port=None,
 5706        port_override=None,
 5707        remote_identity_group_id=None,
 5708        remote_identity_healthcheck_username=None,
 5709        secret_store_id=None,
 5710        tags=None,
 5711    ):
 5712        self.bind_interface = bind_interface if bind_interface is not None else ''
 5713        '''
 5714         Bind interface
 5715        '''
 5716        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5717        self.client_certificate = client_certificate if client_certificate is not None else ''
 5718        self.client_key = client_key if client_key is not None else ''
 5719        self.egress_filter = egress_filter if egress_filter is not None else ''
 5720        '''
 5721         A filter applied to the routing logic to pin datasource to nodes.
 5722        '''
 5723        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5724        '''
 5725         The path used to check the health of your connection.  Defaults to `default`.
 5726        '''
 5727        self.healthy = healthy if healthy is not None else False
 5728        '''
 5729         True if the datasource is reachable and the credentials are valid.
 5730        '''
 5731        self.hostname = hostname if hostname is not None else ''
 5732        self.id = id if id is not None else ''
 5733        '''
 5734         Unique identifier of the Resource.
 5735        '''
 5736        self.name = name if name is not None else ''
 5737        '''
 5738         Unique human-readable name of the Resource.
 5739        '''
 5740        self.port = port if port is not None else 0
 5741        self.port_override = port_override if port_override is not None else 0
 5742        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5743        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5744        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5745        '''
 5746         ID of the secret store containing credentials for this resource, if any.
 5747        '''
 5748        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5749        '''
 5750         Tags is a map of key, value pairs.
 5751        '''
 5752
 5753    def __repr__(self):
 5754        return '<sdm.Kubernetes ' + \
 5755            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5756            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5757            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 5758            'client_key: ' + repr(self.client_key) + ' ' +\
 5759            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5760            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5761            'healthy: ' + repr(self.healthy) + ' ' +\
 5762            'hostname: ' + repr(self.hostname) + ' ' +\
 5763            'id: ' + repr(self.id) + ' ' +\
 5764            'name: ' + repr(self.name) + ' ' +\
 5765            'port: ' + repr(self.port) + ' ' +\
 5766            'port_override: ' + repr(self.port_override) + ' ' +\
 5767            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5768            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5769            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5770            'tags: ' + repr(self.tags) + ' ' +\
 5771            '>'
 5772
 5773    def to_dict(self):
 5774        return {
 5775            'bind_interface': self.bind_interface,
 5776            'certificate_authority': self.certificate_authority,
 5777            'client_certificate': self.client_certificate,
 5778            'client_key': self.client_key,
 5779            'egress_filter': self.egress_filter,
 5780            'healthcheck_namespace': self.healthcheck_namespace,
 5781            'healthy': self.healthy,
 5782            'hostname': self.hostname,
 5783            'id': self.id,
 5784            'name': self.name,
 5785            'port': self.port,
 5786            'port_override': self.port_override,
 5787            'remote_identity_group_id': self.remote_identity_group_id,
 5788            'remote_identity_healthcheck_username':
 5789            self.remote_identity_healthcheck_username,
 5790            'secret_store_id': self.secret_store_id,
 5791            'tags': self.tags,
 5792        }
 5793
 5794    @classmethod
 5795    def from_dict(cls, d):
 5796        return cls(
 5797            bind_interface=d.get('bind_interface'),
 5798            certificate_authority=d.get('certificate_authority'),
 5799            client_certificate=d.get('client_certificate'),
 5800            client_key=d.get('client_key'),
 5801            egress_filter=d.get('egress_filter'),
 5802            healthcheck_namespace=d.get('healthcheck_namespace'),
 5803            healthy=d.get('healthy'),
 5804            hostname=d.get('hostname'),
 5805            id=d.get('id'),
 5806            name=d.get('name'),
 5807            port=d.get('port'),
 5808            port_override=d.get('port_override'),
 5809            remote_identity_group_id=d.get('remote_identity_group_id'),
 5810            remote_identity_healthcheck_username=d.get(
 5811                'remote_identity_healthcheck_username'),
 5812            secret_store_id=d.get('secret_store_id'),
 5813            tags=d.get('tags'),
 5814        )
 5815
 5816
 5817class KubernetesBasicAuth:
 5818    __slots__ = [
 5819        'bind_interface',
 5820        'egress_filter',
 5821        'healthcheck_namespace',
 5822        'healthy',
 5823        'hostname',
 5824        'id',
 5825        'name',
 5826        'password',
 5827        'port',
 5828        'port_override',
 5829        'secret_store_id',
 5830        'tags',
 5831        'username',
 5832    ]
 5833
 5834    def __init__(
 5835        self,
 5836        bind_interface=None,
 5837        egress_filter=None,
 5838        healthcheck_namespace=None,
 5839        healthy=None,
 5840        hostname=None,
 5841        id=None,
 5842        name=None,
 5843        password=None,
 5844        port=None,
 5845        port_override=None,
 5846        secret_store_id=None,
 5847        tags=None,
 5848        username=None,
 5849    ):
 5850        self.bind_interface = bind_interface if bind_interface is not None else ''
 5851        '''
 5852         Bind interface
 5853        '''
 5854        self.egress_filter = egress_filter if egress_filter is not None else ''
 5855        '''
 5856         A filter applied to the routing logic to pin datasource to nodes.
 5857        '''
 5858        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5859        '''
 5860         The path used to check the health of your connection.  Defaults to `default`.
 5861        '''
 5862        self.healthy = healthy if healthy is not None else False
 5863        '''
 5864         True if the datasource is reachable and the credentials are valid.
 5865        '''
 5866        self.hostname = hostname if hostname is not None else ''
 5867        self.id = id if id is not None else ''
 5868        '''
 5869         Unique identifier of the Resource.
 5870        '''
 5871        self.name = name if name is not None else ''
 5872        '''
 5873         Unique human-readable name of the Resource.
 5874        '''
 5875        self.password = password if password is not None else ''
 5876        self.port = port if port is not None else 0
 5877        self.port_override = port_override if port_override is not None else 0
 5878        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5879        '''
 5880         ID of the secret store containing credentials for this resource, if any.
 5881        '''
 5882        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5883        '''
 5884         Tags is a map of key, value pairs.
 5885        '''
 5886        self.username = username if username is not None else ''
 5887
 5888    def __repr__(self):
 5889        return '<sdm.KubernetesBasicAuth ' + \
 5890            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5891            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5892            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5893            'healthy: ' + repr(self.healthy) + ' ' +\
 5894            'hostname: ' + repr(self.hostname) + ' ' +\
 5895            'id: ' + repr(self.id) + ' ' +\
 5896            'name: ' + repr(self.name) + ' ' +\
 5897            'password: ' + repr(self.password) + ' ' +\
 5898            'port: ' + repr(self.port) + ' ' +\
 5899            'port_override: ' + repr(self.port_override) + ' ' +\
 5900            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5901            'tags: ' + repr(self.tags) + ' ' +\
 5902            'username: ' + repr(self.username) + ' ' +\
 5903            '>'
 5904
 5905    def to_dict(self):
 5906        return {
 5907            'bind_interface': self.bind_interface,
 5908            'egress_filter': self.egress_filter,
 5909            'healthcheck_namespace': self.healthcheck_namespace,
 5910            'healthy': self.healthy,
 5911            'hostname': self.hostname,
 5912            'id': self.id,
 5913            'name': self.name,
 5914            'password': self.password,
 5915            'port': self.port,
 5916            'port_override': self.port_override,
 5917            'secret_store_id': self.secret_store_id,
 5918            'tags': self.tags,
 5919            'username': self.username,
 5920        }
 5921
 5922    @classmethod
 5923    def from_dict(cls, d):
 5924        return cls(
 5925            bind_interface=d.get('bind_interface'),
 5926            egress_filter=d.get('egress_filter'),
 5927            healthcheck_namespace=d.get('healthcheck_namespace'),
 5928            healthy=d.get('healthy'),
 5929            hostname=d.get('hostname'),
 5930            id=d.get('id'),
 5931            name=d.get('name'),
 5932            password=d.get('password'),
 5933            port=d.get('port'),
 5934            port_override=d.get('port_override'),
 5935            secret_store_id=d.get('secret_store_id'),
 5936            tags=d.get('tags'),
 5937            username=d.get('username'),
 5938        )
 5939
 5940
 5941class KubernetesServiceAccount:
 5942    __slots__ = [
 5943        'bind_interface',
 5944        'egress_filter',
 5945        'healthcheck_namespace',
 5946        'healthy',
 5947        'hostname',
 5948        'id',
 5949        'name',
 5950        'port',
 5951        'port_override',
 5952        'remote_identity_group_id',
 5953        'remote_identity_healthcheck_username',
 5954        'secret_store_id',
 5955        'tags',
 5956        'token',
 5957    ]
 5958
 5959    def __init__(
 5960        self,
 5961        bind_interface=None,
 5962        egress_filter=None,
 5963        healthcheck_namespace=None,
 5964        healthy=None,
 5965        hostname=None,
 5966        id=None,
 5967        name=None,
 5968        port=None,
 5969        port_override=None,
 5970        remote_identity_group_id=None,
 5971        remote_identity_healthcheck_username=None,
 5972        secret_store_id=None,
 5973        tags=None,
 5974        token=None,
 5975    ):
 5976        self.bind_interface = bind_interface if bind_interface is not None else ''
 5977        '''
 5978         Bind interface
 5979        '''
 5980        self.egress_filter = egress_filter if egress_filter is not None else ''
 5981        '''
 5982         A filter applied to the routing logic to pin datasource to nodes.
 5983        '''
 5984        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5985        '''
 5986         The path used to check the health of your connection.  Defaults to `default`.
 5987        '''
 5988        self.healthy = healthy if healthy is not None else False
 5989        '''
 5990         True if the datasource is reachable and the credentials are valid.
 5991        '''
 5992        self.hostname = hostname if hostname is not None else ''
 5993        self.id = id if id is not None else ''
 5994        '''
 5995         Unique identifier of the Resource.
 5996        '''
 5997        self.name = name if name is not None else ''
 5998        '''
 5999         Unique human-readable name of the Resource.
 6000        '''
 6001        self.port = port if port is not None else 0
 6002        self.port_override = port_override if port_override is not None else 0
 6003        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6004        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6005        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6006        '''
 6007         ID of the secret store containing credentials for this resource, if any.
 6008        '''
 6009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6010        '''
 6011         Tags is a map of key, value pairs.
 6012        '''
 6013        self.token = token if token is not None else ''
 6014
 6015    def __repr__(self):
 6016        return '<sdm.KubernetesServiceAccount ' + \
 6017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6019            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6020            'healthy: ' + repr(self.healthy) + ' ' +\
 6021            'hostname: ' + repr(self.hostname) + ' ' +\
 6022            'id: ' + repr(self.id) + ' ' +\
 6023            'name: ' + repr(self.name) + ' ' +\
 6024            'port: ' + repr(self.port) + ' ' +\
 6025            'port_override: ' + repr(self.port_override) + ' ' +\
 6026            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6027            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6029            'tags: ' + repr(self.tags) + ' ' +\
 6030            'token: ' + repr(self.token) + ' ' +\
 6031            '>'
 6032
 6033    def to_dict(self):
 6034        return {
 6035            'bind_interface': self.bind_interface,
 6036            'egress_filter': self.egress_filter,
 6037            'healthcheck_namespace': self.healthcheck_namespace,
 6038            'healthy': self.healthy,
 6039            'hostname': self.hostname,
 6040            'id': self.id,
 6041            'name': self.name,
 6042            'port': self.port,
 6043            'port_override': self.port_override,
 6044            'remote_identity_group_id': self.remote_identity_group_id,
 6045            'remote_identity_healthcheck_username':
 6046            self.remote_identity_healthcheck_username,
 6047            'secret_store_id': self.secret_store_id,
 6048            'tags': self.tags,
 6049            'token': self.token,
 6050        }
 6051
 6052    @classmethod
 6053    def from_dict(cls, d):
 6054        return cls(
 6055            bind_interface=d.get('bind_interface'),
 6056            egress_filter=d.get('egress_filter'),
 6057            healthcheck_namespace=d.get('healthcheck_namespace'),
 6058            healthy=d.get('healthy'),
 6059            hostname=d.get('hostname'),
 6060            id=d.get('id'),
 6061            name=d.get('name'),
 6062            port=d.get('port'),
 6063            port_override=d.get('port_override'),
 6064            remote_identity_group_id=d.get('remote_identity_group_id'),
 6065            remote_identity_healthcheck_username=d.get(
 6066                'remote_identity_healthcheck_username'),
 6067            secret_store_id=d.get('secret_store_id'),
 6068            tags=d.get('tags'),
 6069            token=d.get('token'),
 6070        )
 6071
 6072
 6073class KubernetesServiceAccountUserImpersonation:
 6074    __slots__ = [
 6075        'bind_interface',
 6076        'egress_filter',
 6077        'healthcheck_namespace',
 6078        'healthy',
 6079        'hostname',
 6080        'id',
 6081        'name',
 6082        'port',
 6083        'port_override',
 6084        'secret_store_id',
 6085        'tags',
 6086        'token',
 6087    ]
 6088
 6089    def __init__(
 6090        self,
 6091        bind_interface=None,
 6092        egress_filter=None,
 6093        healthcheck_namespace=None,
 6094        healthy=None,
 6095        hostname=None,
 6096        id=None,
 6097        name=None,
 6098        port=None,
 6099        port_override=None,
 6100        secret_store_id=None,
 6101        tags=None,
 6102        token=None,
 6103    ):
 6104        self.bind_interface = bind_interface if bind_interface is not None else ''
 6105        '''
 6106         Bind interface
 6107        '''
 6108        self.egress_filter = egress_filter if egress_filter is not None else ''
 6109        '''
 6110         A filter applied to the routing logic to pin datasource to nodes.
 6111        '''
 6112        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6113        '''
 6114         The path used to check the health of your connection.  Defaults to `default`.
 6115        '''
 6116        self.healthy = healthy if healthy is not None else False
 6117        '''
 6118         True if the datasource is reachable and the credentials are valid.
 6119        '''
 6120        self.hostname = hostname if hostname is not None else ''
 6121        self.id = id if id is not None else ''
 6122        '''
 6123         Unique identifier of the Resource.
 6124        '''
 6125        self.name = name if name is not None else ''
 6126        '''
 6127         Unique human-readable name of the Resource.
 6128        '''
 6129        self.port = port if port is not None else 0
 6130        self.port_override = port_override if port_override is not None else 0
 6131        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6132        '''
 6133         ID of the secret store containing credentials for this resource, if any.
 6134        '''
 6135        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6136        '''
 6137         Tags is a map of key, value pairs.
 6138        '''
 6139        self.token = token if token is not None else ''
 6140
 6141    def __repr__(self):
 6142        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6143            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6144            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6145            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6146            'healthy: ' + repr(self.healthy) + ' ' +\
 6147            'hostname: ' + repr(self.hostname) + ' ' +\
 6148            'id: ' + repr(self.id) + ' ' +\
 6149            'name: ' + repr(self.name) + ' ' +\
 6150            'port: ' + repr(self.port) + ' ' +\
 6151            'port_override: ' + repr(self.port_override) + ' ' +\
 6152            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6153            'tags: ' + repr(self.tags) + ' ' +\
 6154            'token: ' + repr(self.token) + ' ' +\
 6155            '>'
 6156
 6157    def to_dict(self):
 6158        return {
 6159            'bind_interface': self.bind_interface,
 6160            'egress_filter': self.egress_filter,
 6161            'healthcheck_namespace': self.healthcheck_namespace,
 6162            'healthy': self.healthy,
 6163            'hostname': self.hostname,
 6164            'id': self.id,
 6165            'name': self.name,
 6166            'port': self.port,
 6167            'port_override': self.port_override,
 6168            'secret_store_id': self.secret_store_id,
 6169            'tags': self.tags,
 6170            'token': self.token,
 6171        }
 6172
 6173    @classmethod
 6174    def from_dict(cls, d):
 6175        return cls(
 6176            bind_interface=d.get('bind_interface'),
 6177            egress_filter=d.get('egress_filter'),
 6178            healthcheck_namespace=d.get('healthcheck_namespace'),
 6179            healthy=d.get('healthy'),
 6180            hostname=d.get('hostname'),
 6181            id=d.get('id'),
 6182            name=d.get('name'),
 6183            port=d.get('port'),
 6184            port_override=d.get('port_override'),
 6185            secret_store_id=d.get('secret_store_id'),
 6186            tags=d.get('tags'),
 6187            token=d.get('token'),
 6188        )
 6189
 6190
 6191class KubernetesUserImpersonation:
 6192    __slots__ = [
 6193        'bind_interface',
 6194        'certificate_authority',
 6195        'client_certificate',
 6196        'client_key',
 6197        'egress_filter',
 6198        'healthcheck_namespace',
 6199        'healthy',
 6200        'hostname',
 6201        'id',
 6202        'name',
 6203        'port',
 6204        'port_override',
 6205        'secret_store_id',
 6206        'tags',
 6207    ]
 6208
 6209    def __init__(
 6210        self,
 6211        bind_interface=None,
 6212        certificate_authority=None,
 6213        client_certificate=None,
 6214        client_key=None,
 6215        egress_filter=None,
 6216        healthcheck_namespace=None,
 6217        healthy=None,
 6218        hostname=None,
 6219        id=None,
 6220        name=None,
 6221        port=None,
 6222        port_override=None,
 6223        secret_store_id=None,
 6224        tags=None,
 6225    ):
 6226        self.bind_interface = bind_interface if bind_interface is not None else ''
 6227        '''
 6228         Bind interface
 6229        '''
 6230        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6231        self.client_certificate = client_certificate if client_certificate is not None else ''
 6232        self.client_key = client_key if client_key is not None else ''
 6233        self.egress_filter = egress_filter if egress_filter is not None else ''
 6234        '''
 6235         A filter applied to the routing logic to pin datasource to nodes.
 6236        '''
 6237        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6238        '''
 6239         The path used to check the health of your connection.  Defaults to `default`.
 6240        '''
 6241        self.healthy = healthy if healthy is not None else False
 6242        '''
 6243         True if the datasource is reachable and the credentials are valid.
 6244        '''
 6245        self.hostname = hostname if hostname is not None else ''
 6246        self.id = id if id is not None else ''
 6247        '''
 6248         Unique identifier of the Resource.
 6249        '''
 6250        self.name = name if name is not None else ''
 6251        '''
 6252         Unique human-readable name of the Resource.
 6253        '''
 6254        self.port = port if port is not None else 0
 6255        self.port_override = port_override if port_override is not None else 0
 6256        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6257        '''
 6258         ID of the secret store containing credentials for this resource, if any.
 6259        '''
 6260        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6261        '''
 6262         Tags is a map of key, value pairs.
 6263        '''
 6264
 6265    def __repr__(self):
 6266        return '<sdm.KubernetesUserImpersonation ' + \
 6267            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6268            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6269            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6270            'client_key: ' + repr(self.client_key) + ' ' +\
 6271            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6272            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6273            'healthy: ' + repr(self.healthy) + ' ' +\
 6274            'hostname: ' + repr(self.hostname) + ' ' +\
 6275            'id: ' + repr(self.id) + ' ' +\
 6276            'name: ' + repr(self.name) + ' ' +\
 6277            'port: ' + repr(self.port) + ' ' +\
 6278            'port_override: ' + repr(self.port_override) + ' ' +\
 6279            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6280            'tags: ' + repr(self.tags) + ' ' +\
 6281            '>'
 6282
 6283    def to_dict(self):
 6284        return {
 6285            'bind_interface': self.bind_interface,
 6286            'certificate_authority': self.certificate_authority,
 6287            'client_certificate': self.client_certificate,
 6288            'client_key': self.client_key,
 6289            'egress_filter': self.egress_filter,
 6290            'healthcheck_namespace': self.healthcheck_namespace,
 6291            'healthy': self.healthy,
 6292            'hostname': self.hostname,
 6293            'id': self.id,
 6294            'name': self.name,
 6295            'port': self.port,
 6296            'port_override': self.port_override,
 6297            'secret_store_id': self.secret_store_id,
 6298            'tags': self.tags,
 6299        }
 6300
 6301    @classmethod
 6302    def from_dict(cls, d):
 6303        return cls(
 6304            bind_interface=d.get('bind_interface'),
 6305            certificate_authority=d.get('certificate_authority'),
 6306            client_certificate=d.get('client_certificate'),
 6307            client_key=d.get('client_key'),
 6308            egress_filter=d.get('egress_filter'),
 6309            healthcheck_namespace=d.get('healthcheck_namespace'),
 6310            healthy=d.get('healthy'),
 6311            hostname=d.get('hostname'),
 6312            id=d.get('id'),
 6313            name=d.get('name'),
 6314            port=d.get('port'),
 6315            port_override=d.get('port_override'),
 6316            secret_store_id=d.get('secret_store_id'),
 6317            tags=d.get('tags'),
 6318        )
 6319
 6320
 6321class MTLSMysql:
 6322    '''
 6323    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6324    without a major version bump.
 6325    '''
 6326    __slots__ = [
 6327        'bind_interface',
 6328        'certificate_authority',
 6329        'client_certificate',
 6330        'client_key',
 6331        'database',
 6332        'egress_filter',
 6333        'healthy',
 6334        'hostname',
 6335        'id',
 6336        'name',
 6337        'password',
 6338        'port',
 6339        'port_override',
 6340        'secret_store_id',
 6341        'server_name',
 6342        'tags',
 6343        'username',
 6344    ]
 6345
 6346    def __init__(
 6347        self,
 6348        bind_interface=None,
 6349        certificate_authority=None,
 6350        client_certificate=None,
 6351        client_key=None,
 6352        database=None,
 6353        egress_filter=None,
 6354        healthy=None,
 6355        hostname=None,
 6356        id=None,
 6357        name=None,
 6358        password=None,
 6359        port=None,
 6360        port_override=None,
 6361        secret_store_id=None,
 6362        server_name=None,
 6363        tags=None,
 6364        username=None,
 6365    ):
 6366        self.bind_interface = bind_interface if bind_interface is not None else ''
 6367        '''
 6368         Bind interface
 6369        '''
 6370        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6371        self.client_certificate = client_certificate if client_certificate is not None else ''
 6372        self.client_key = client_key if client_key is not None else ''
 6373        self.database = database if database is not None else ''
 6374        self.egress_filter = egress_filter if egress_filter is not None else ''
 6375        '''
 6376         A filter applied to the routing logic to pin datasource to nodes.
 6377        '''
 6378        self.healthy = healthy if healthy is not None else False
 6379        '''
 6380         True if the datasource is reachable and the credentials are valid.
 6381        '''
 6382        self.hostname = hostname if hostname is not None else ''
 6383        self.id = id if id is not None else ''
 6384        '''
 6385         Unique identifier of the Resource.
 6386        '''
 6387        self.name = name if name is not None else ''
 6388        '''
 6389         Unique human-readable name of the Resource.
 6390        '''
 6391        self.password = password if password is not None else ''
 6392        self.port = port if port is not None else 0
 6393        self.port_override = port_override if port_override is not None else 0
 6394        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6395        '''
 6396         ID of the secret store containing credentials for this resource, if any.
 6397        '''
 6398        self.server_name = server_name if server_name is not None else ''
 6399        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6400        '''
 6401         Tags is a map of key, value pairs.
 6402        '''
 6403        self.username = username if username is not None else ''
 6404
 6405    def __repr__(self):
 6406        return '<sdm.MTLSMysql ' + \
 6407            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6408            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6409            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6410            'client_key: ' + repr(self.client_key) + ' ' +\
 6411            'database: ' + repr(self.database) + ' ' +\
 6412            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6413            'healthy: ' + repr(self.healthy) + ' ' +\
 6414            'hostname: ' + repr(self.hostname) + ' ' +\
 6415            'id: ' + repr(self.id) + ' ' +\
 6416            'name: ' + repr(self.name) + ' ' +\
 6417            'password: ' + repr(self.password) + ' ' +\
 6418            'port: ' + repr(self.port) + ' ' +\
 6419            'port_override: ' + repr(self.port_override) + ' ' +\
 6420            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6421            'server_name: ' + repr(self.server_name) + ' ' +\
 6422            'tags: ' + repr(self.tags) + ' ' +\
 6423            'username: ' + repr(self.username) + ' ' +\
 6424            '>'
 6425
 6426    def to_dict(self):
 6427        return {
 6428            'bind_interface': self.bind_interface,
 6429            'certificate_authority': self.certificate_authority,
 6430            'client_certificate': self.client_certificate,
 6431            'client_key': self.client_key,
 6432            'database': self.database,
 6433            'egress_filter': self.egress_filter,
 6434            'healthy': self.healthy,
 6435            'hostname': self.hostname,
 6436            'id': self.id,
 6437            'name': self.name,
 6438            'password': self.password,
 6439            'port': self.port,
 6440            'port_override': self.port_override,
 6441            'secret_store_id': self.secret_store_id,
 6442            'server_name': self.server_name,
 6443            'tags': self.tags,
 6444            'username': self.username,
 6445        }
 6446
 6447    @classmethod
 6448    def from_dict(cls, d):
 6449        return cls(
 6450            bind_interface=d.get('bind_interface'),
 6451            certificate_authority=d.get('certificate_authority'),
 6452            client_certificate=d.get('client_certificate'),
 6453            client_key=d.get('client_key'),
 6454            database=d.get('database'),
 6455            egress_filter=d.get('egress_filter'),
 6456            healthy=d.get('healthy'),
 6457            hostname=d.get('hostname'),
 6458            id=d.get('id'),
 6459            name=d.get('name'),
 6460            password=d.get('password'),
 6461            port=d.get('port'),
 6462            port_override=d.get('port_override'),
 6463            secret_store_id=d.get('secret_store_id'),
 6464            server_name=d.get('server_name'),
 6465            tags=d.get('tags'),
 6466            username=d.get('username'),
 6467        )
 6468
 6469
 6470class MTLSPostgres:
 6471    __slots__ = [
 6472        'bind_interface',
 6473        'certificate_authority',
 6474        'client_certificate',
 6475        'client_key',
 6476        'database',
 6477        'egress_filter',
 6478        'healthy',
 6479        'hostname',
 6480        'id',
 6481        'name',
 6482        'override_database',
 6483        'password',
 6484        'port',
 6485        'port_override',
 6486        'secret_store_id',
 6487        'server_name',
 6488        'tags',
 6489        'username',
 6490    ]
 6491
 6492    def __init__(
 6493        self,
 6494        bind_interface=None,
 6495        certificate_authority=None,
 6496        client_certificate=None,
 6497        client_key=None,
 6498        database=None,
 6499        egress_filter=None,
 6500        healthy=None,
 6501        hostname=None,
 6502        id=None,
 6503        name=None,
 6504        override_database=None,
 6505        password=None,
 6506        port=None,
 6507        port_override=None,
 6508        secret_store_id=None,
 6509        server_name=None,
 6510        tags=None,
 6511        username=None,
 6512    ):
 6513        self.bind_interface = bind_interface if bind_interface is not None else ''
 6514        '''
 6515         Bind interface
 6516        '''
 6517        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6518        self.client_certificate = client_certificate if client_certificate is not None else ''
 6519        self.client_key = client_key if client_key is not None else ''
 6520        self.database = database if database is not None else ''
 6521        self.egress_filter = egress_filter if egress_filter is not None else ''
 6522        '''
 6523         A filter applied to the routing logic to pin datasource to nodes.
 6524        '''
 6525        self.healthy = healthy if healthy is not None else False
 6526        '''
 6527         True if the datasource is reachable and the credentials are valid.
 6528        '''
 6529        self.hostname = hostname if hostname is not None else ''
 6530        self.id = id if id is not None else ''
 6531        '''
 6532         Unique identifier of the Resource.
 6533        '''
 6534        self.name = name if name is not None else ''
 6535        '''
 6536         Unique human-readable name of the Resource.
 6537        '''
 6538        self.override_database = override_database if override_database is not None else False
 6539        self.password = password if password is not None else ''
 6540        self.port = port if port is not None else 0
 6541        self.port_override = port_override if port_override is not None else 0
 6542        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6543        '''
 6544         ID of the secret store containing credentials for this resource, if any.
 6545        '''
 6546        self.server_name = server_name if server_name is not None else ''
 6547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6548        '''
 6549         Tags is a map of key, value pairs.
 6550        '''
 6551        self.username = username if username is not None else ''
 6552
 6553    def __repr__(self):
 6554        return '<sdm.MTLSPostgres ' + \
 6555            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6556            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6557            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6558            'client_key: ' + repr(self.client_key) + ' ' +\
 6559            'database: ' + repr(self.database) + ' ' +\
 6560            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6561            'healthy: ' + repr(self.healthy) + ' ' +\
 6562            'hostname: ' + repr(self.hostname) + ' ' +\
 6563            'id: ' + repr(self.id) + ' ' +\
 6564            'name: ' + repr(self.name) + ' ' +\
 6565            'override_database: ' + repr(self.override_database) + ' ' +\
 6566            'password: ' + repr(self.password) + ' ' +\
 6567            'port: ' + repr(self.port) + ' ' +\
 6568            'port_override: ' + repr(self.port_override) + ' ' +\
 6569            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6570            'server_name: ' + repr(self.server_name) + ' ' +\
 6571            'tags: ' + repr(self.tags) + ' ' +\
 6572            'username: ' + repr(self.username) + ' ' +\
 6573            '>'
 6574
 6575    def to_dict(self):
 6576        return {
 6577            'bind_interface': self.bind_interface,
 6578            'certificate_authority': self.certificate_authority,
 6579            'client_certificate': self.client_certificate,
 6580            'client_key': self.client_key,
 6581            'database': self.database,
 6582            'egress_filter': self.egress_filter,
 6583            'healthy': self.healthy,
 6584            'hostname': self.hostname,
 6585            'id': self.id,
 6586            'name': self.name,
 6587            'override_database': self.override_database,
 6588            'password': self.password,
 6589            'port': self.port,
 6590            'port_override': self.port_override,
 6591            'secret_store_id': self.secret_store_id,
 6592            'server_name': self.server_name,
 6593            'tags': self.tags,
 6594            'username': self.username,
 6595        }
 6596
 6597    @classmethod
 6598    def from_dict(cls, d):
 6599        return cls(
 6600            bind_interface=d.get('bind_interface'),
 6601            certificate_authority=d.get('certificate_authority'),
 6602            client_certificate=d.get('client_certificate'),
 6603            client_key=d.get('client_key'),
 6604            database=d.get('database'),
 6605            egress_filter=d.get('egress_filter'),
 6606            healthy=d.get('healthy'),
 6607            hostname=d.get('hostname'),
 6608            id=d.get('id'),
 6609            name=d.get('name'),
 6610            override_database=d.get('override_database'),
 6611            password=d.get('password'),
 6612            port=d.get('port'),
 6613            port_override=d.get('port_override'),
 6614            secret_store_id=d.get('secret_store_id'),
 6615            server_name=d.get('server_name'),
 6616            tags=d.get('tags'),
 6617            username=d.get('username'),
 6618        )
 6619
 6620
 6621class Maria:
 6622    __slots__ = [
 6623        'bind_interface',
 6624        'database',
 6625        'egress_filter',
 6626        'healthy',
 6627        'hostname',
 6628        'id',
 6629        'name',
 6630        'password',
 6631        'port',
 6632        'port_override',
 6633        'secret_store_id',
 6634        'tags',
 6635        'username',
 6636    ]
 6637
 6638    def __init__(
 6639        self,
 6640        bind_interface=None,
 6641        database=None,
 6642        egress_filter=None,
 6643        healthy=None,
 6644        hostname=None,
 6645        id=None,
 6646        name=None,
 6647        password=None,
 6648        port=None,
 6649        port_override=None,
 6650        secret_store_id=None,
 6651        tags=None,
 6652        username=None,
 6653    ):
 6654        self.bind_interface = bind_interface if bind_interface is not None else ''
 6655        '''
 6656         Bind interface
 6657        '''
 6658        self.database = database if database is not None else ''
 6659        self.egress_filter = egress_filter if egress_filter is not None else ''
 6660        '''
 6661         A filter applied to the routing logic to pin datasource to nodes.
 6662        '''
 6663        self.healthy = healthy if healthy is not None else False
 6664        '''
 6665         True if the datasource is reachable and the credentials are valid.
 6666        '''
 6667        self.hostname = hostname if hostname is not None else ''
 6668        self.id = id if id is not None else ''
 6669        '''
 6670         Unique identifier of the Resource.
 6671        '''
 6672        self.name = name if name is not None else ''
 6673        '''
 6674         Unique human-readable name of the Resource.
 6675        '''
 6676        self.password = password if password is not None else ''
 6677        self.port = port if port is not None else 0
 6678        self.port_override = port_override if port_override is not None else 0
 6679        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6680        '''
 6681         ID of the secret store containing credentials for this resource, if any.
 6682        '''
 6683        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6684        '''
 6685         Tags is a map of key, value pairs.
 6686        '''
 6687        self.username = username if username is not None else ''
 6688
 6689    def __repr__(self):
 6690        return '<sdm.Maria ' + \
 6691            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6692            'database: ' + repr(self.database) + ' ' +\
 6693            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6694            'healthy: ' + repr(self.healthy) + ' ' +\
 6695            'hostname: ' + repr(self.hostname) + ' ' +\
 6696            'id: ' + repr(self.id) + ' ' +\
 6697            'name: ' + repr(self.name) + ' ' +\
 6698            'password: ' + repr(self.password) + ' ' +\
 6699            'port: ' + repr(self.port) + ' ' +\
 6700            'port_override: ' + repr(self.port_override) + ' ' +\
 6701            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6702            'tags: ' + repr(self.tags) + ' ' +\
 6703            'username: ' + repr(self.username) + ' ' +\
 6704            '>'
 6705
 6706    def to_dict(self):
 6707        return {
 6708            'bind_interface': self.bind_interface,
 6709            'database': self.database,
 6710            'egress_filter': self.egress_filter,
 6711            'healthy': self.healthy,
 6712            'hostname': self.hostname,
 6713            'id': self.id,
 6714            'name': self.name,
 6715            'password': self.password,
 6716            'port': self.port,
 6717            'port_override': self.port_override,
 6718            'secret_store_id': self.secret_store_id,
 6719            'tags': self.tags,
 6720            'username': self.username,
 6721        }
 6722
 6723    @classmethod
 6724    def from_dict(cls, d):
 6725        return cls(
 6726            bind_interface=d.get('bind_interface'),
 6727            database=d.get('database'),
 6728            egress_filter=d.get('egress_filter'),
 6729            healthy=d.get('healthy'),
 6730            hostname=d.get('hostname'),
 6731            id=d.get('id'),
 6732            name=d.get('name'),
 6733            password=d.get('password'),
 6734            port=d.get('port'),
 6735            port_override=d.get('port_override'),
 6736            secret_store_id=d.get('secret_store_id'),
 6737            tags=d.get('tags'),
 6738            username=d.get('username'),
 6739        )
 6740
 6741
 6742class Memcached:
 6743    __slots__ = [
 6744        'bind_interface',
 6745        'egress_filter',
 6746        'healthy',
 6747        'hostname',
 6748        'id',
 6749        'name',
 6750        'port',
 6751        'port_override',
 6752        'secret_store_id',
 6753        'tags',
 6754    ]
 6755
 6756    def __init__(
 6757        self,
 6758        bind_interface=None,
 6759        egress_filter=None,
 6760        healthy=None,
 6761        hostname=None,
 6762        id=None,
 6763        name=None,
 6764        port=None,
 6765        port_override=None,
 6766        secret_store_id=None,
 6767        tags=None,
 6768    ):
 6769        self.bind_interface = bind_interface if bind_interface is not None else ''
 6770        '''
 6771         Bind interface
 6772        '''
 6773        self.egress_filter = egress_filter if egress_filter is not None else ''
 6774        '''
 6775         A filter applied to the routing logic to pin datasource to nodes.
 6776        '''
 6777        self.healthy = healthy if healthy is not None else False
 6778        '''
 6779         True if the datasource is reachable and the credentials are valid.
 6780        '''
 6781        self.hostname = hostname if hostname is not None else ''
 6782        self.id = id if id is not None else ''
 6783        '''
 6784         Unique identifier of the Resource.
 6785        '''
 6786        self.name = name if name is not None else ''
 6787        '''
 6788         Unique human-readable name of the Resource.
 6789        '''
 6790        self.port = port if port is not None else 0
 6791        self.port_override = port_override if port_override is not None else 0
 6792        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6793        '''
 6794         ID of the secret store containing credentials for this resource, if any.
 6795        '''
 6796        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6797        '''
 6798         Tags is a map of key, value pairs.
 6799        '''
 6800
 6801    def __repr__(self):
 6802        return '<sdm.Memcached ' + \
 6803            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6804            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6805            'healthy: ' + repr(self.healthy) + ' ' +\
 6806            'hostname: ' + repr(self.hostname) + ' ' +\
 6807            'id: ' + repr(self.id) + ' ' +\
 6808            'name: ' + repr(self.name) + ' ' +\
 6809            'port: ' + repr(self.port) + ' ' +\
 6810            'port_override: ' + repr(self.port_override) + ' ' +\
 6811            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6812            'tags: ' + repr(self.tags) + ' ' +\
 6813            '>'
 6814
 6815    def to_dict(self):
 6816        return {
 6817            'bind_interface': self.bind_interface,
 6818            'egress_filter': self.egress_filter,
 6819            'healthy': self.healthy,
 6820            'hostname': self.hostname,
 6821            'id': self.id,
 6822            'name': self.name,
 6823            'port': self.port,
 6824            'port_override': self.port_override,
 6825            'secret_store_id': self.secret_store_id,
 6826            'tags': self.tags,
 6827        }
 6828
 6829    @classmethod
 6830    def from_dict(cls, d):
 6831        return cls(
 6832            bind_interface=d.get('bind_interface'),
 6833            egress_filter=d.get('egress_filter'),
 6834            healthy=d.get('healthy'),
 6835            hostname=d.get('hostname'),
 6836            id=d.get('id'),
 6837            name=d.get('name'),
 6838            port=d.get('port'),
 6839            port_override=d.get('port_override'),
 6840            secret_store_id=d.get('secret_store_id'),
 6841            tags=d.get('tags'),
 6842        )
 6843
 6844
 6845class Memsql:
 6846    __slots__ = [
 6847        'bind_interface',
 6848        'database',
 6849        'egress_filter',
 6850        'healthy',
 6851        'hostname',
 6852        'id',
 6853        'name',
 6854        'password',
 6855        'port',
 6856        'port_override',
 6857        'secret_store_id',
 6858        'tags',
 6859        'username',
 6860    ]
 6861
 6862    def __init__(
 6863        self,
 6864        bind_interface=None,
 6865        database=None,
 6866        egress_filter=None,
 6867        healthy=None,
 6868        hostname=None,
 6869        id=None,
 6870        name=None,
 6871        password=None,
 6872        port=None,
 6873        port_override=None,
 6874        secret_store_id=None,
 6875        tags=None,
 6876        username=None,
 6877    ):
 6878        self.bind_interface = bind_interface if bind_interface is not None else ''
 6879        '''
 6880         Bind interface
 6881        '''
 6882        self.database = database if database is not None else ''
 6883        self.egress_filter = egress_filter if egress_filter is not None else ''
 6884        '''
 6885         A filter applied to the routing logic to pin datasource to nodes.
 6886        '''
 6887        self.healthy = healthy if healthy is not None else False
 6888        '''
 6889         True if the datasource is reachable and the credentials are valid.
 6890        '''
 6891        self.hostname = hostname if hostname is not None else ''
 6892        self.id = id if id is not None else ''
 6893        '''
 6894         Unique identifier of the Resource.
 6895        '''
 6896        self.name = name if name is not None else ''
 6897        '''
 6898         Unique human-readable name of the Resource.
 6899        '''
 6900        self.password = password if password is not None else ''
 6901        self.port = port if port is not None else 0
 6902        self.port_override = port_override if port_override is not None else 0
 6903        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6904        '''
 6905         ID of the secret store containing credentials for this resource, if any.
 6906        '''
 6907        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6908        '''
 6909         Tags is a map of key, value pairs.
 6910        '''
 6911        self.username = username if username is not None else ''
 6912
 6913    def __repr__(self):
 6914        return '<sdm.Memsql ' + \
 6915            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6916            'database: ' + repr(self.database) + ' ' +\
 6917            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6918            'healthy: ' + repr(self.healthy) + ' ' +\
 6919            'hostname: ' + repr(self.hostname) + ' ' +\
 6920            'id: ' + repr(self.id) + ' ' +\
 6921            'name: ' + repr(self.name) + ' ' +\
 6922            'password: ' + repr(self.password) + ' ' +\
 6923            'port: ' + repr(self.port) + ' ' +\
 6924            'port_override: ' + repr(self.port_override) + ' ' +\
 6925            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6926            'tags: ' + repr(self.tags) + ' ' +\
 6927            'username: ' + repr(self.username) + ' ' +\
 6928            '>'
 6929
 6930    def to_dict(self):
 6931        return {
 6932            'bind_interface': self.bind_interface,
 6933            'database': self.database,
 6934            'egress_filter': self.egress_filter,
 6935            'healthy': self.healthy,
 6936            'hostname': self.hostname,
 6937            'id': self.id,
 6938            'name': self.name,
 6939            'password': self.password,
 6940            'port': self.port,
 6941            'port_override': self.port_override,
 6942            'secret_store_id': self.secret_store_id,
 6943            'tags': self.tags,
 6944            'username': self.username,
 6945        }
 6946
 6947    @classmethod
 6948    def from_dict(cls, d):
 6949        return cls(
 6950            bind_interface=d.get('bind_interface'),
 6951            database=d.get('database'),
 6952            egress_filter=d.get('egress_filter'),
 6953            healthy=d.get('healthy'),
 6954            hostname=d.get('hostname'),
 6955            id=d.get('id'),
 6956            name=d.get('name'),
 6957            password=d.get('password'),
 6958            port=d.get('port'),
 6959            port_override=d.get('port_override'),
 6960            secret_store_id=d.get('secret_store_id'),
 6961            tags=d.get('tags'),
 6962            username=d.get('username'),
 6963        )
 6964
 6965
 6966class MongoHost:
 6967    '''
 6968    MongoHost is currently unstable, and its API may change, or it may be removed,
 6969    without a major version bump.
 6970    '''
 6971    __slots__ = [
 6972        'auth_database',
 6973        'bind_interface',
 6974        'egress_filter',
 6975        'healthy',
 6976        'hostname',
 6977        'id',
 6978        'name',
 6979        'password',
 6980        'port',
 6981        'port_override',
 6982        'secret_store_id',
 6983        'tags',
 6984        'tls_required',
 6985        'username',
 6986    ]
 6987
 6988    def __init__(
 6989        self,
 6990        auth_database=None,
 6991        bind_interface=None,
 6992        egress_filter=None,
 6993        healthy=None,
 6994        hostname=None,
 6995        id=None,
 6996        name=None,
 6997        password=None,
 6998        port=None,
 6999        port_override=None,
 7000        secret_store_id=None,
 7001        tags=None,
 7002        tls_required=None,
 7003        username=None,
 7004    ):
 7005        self.auth_database = auth_database if auth_database is not None else ''
 7006        self.bind_interface = bind_interface if bind_interface is not None else ''
 7007        '''
 7008         Bind interface
 7009        '''
 7010        self.egress_filter = egress_filter if egress_filter is not None else ''
 7011        '''
 7012         A filter applied to the routing logic to pin datasource to nodes.
 7013        '''
 7014        self.healthy = healthy if healthy is not None else False
 7015        '''
 7016         True if the datasource is reachable and the credentials are valid.
 7017        '''
 7018        self.hostname = hostname if hostname is not None else ''
 7019        self.id = id if id is not None else ''
 7020        '''
 7021         Unique identifier of the Resource.
 7022        '''
 7023        self.name = name if name is not None else ''
 7024        '''
 7025         Unique human-readable name of the Resource.
 7026        '''
 7027        self.password = password if password is not None else ''
 7028        self.port = port if port is not None else 0
 7029        self.port_override = port_override if port_override is not None else 0
 7030        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7031        '''
 7032         ID of the secret store containing credentials for this resource, if any.
 7033        '''
 7034        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7035        '''
 7036         Tags is a map of key, value pairs.
 7037        '''
 7038        self.tls_required = tls_required if tls_required is not None else False
 7039        self.username = username if username is not None else ''
 7040
 7041    def __repr__(self):
 7042        return '<sdm.MongoHost ' + \
 7043            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7044            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7045            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7046            'healthy: ' + repr(self.healthy) + ' ' +\
 7047            'hostname: ' + repr(self.hostname) + ' ' +\
 7048            'id: ' + repr(self.id) + ' ' +\
 7049            'name: ' + repr(self.name) + ' ' +\
 7050            'password: ' + repr(self.password) + ' ' +\
 7051            'port: ' + repr(self.port) + ' ' +\
 7052            'port_override: ' + repr(self.port_override) + ' ' +\
 7053            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7054            'tags: ' + repr(self.tags) + ' ' +\
 7055            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7056            'username: ' + repr(self.username) + ' ' +\
 7057            '>'
 7058
 7059    def to_dict(self):
 7060        return {
 7061            'auth_database': self.auth_database,
 7062            'bind_interface': self.bind_interface,
 7063            'egress_filter': self.egress_filter,
 7064            'healthy': self.healthy,
 7065            'hostname': self.hostname,
 7066            'id': self.id,
 7067            'name': self.name,
 7068            'password': self.password,
 7069            'port': self.port,
 7070            'port_override': self.port_override,
 7071            'secret_store_id': self.secret_store_id,
 7072            'tags': self.tags,
 7073            'tls_required': self.tls_required,
 7074            'username': self.username,
 7075        }
 7076
 7077    @classmethod
 7078    def from_dict(cls, d):
 7079        return cls(
 7080            auth_database=d.get('auth_database'),
 7081            bind_interface=d.get('bind_interface'),
 7082            egress_filter=d.get('egress_filter'),
 7083            healthy=d.get('healthy'),
 7084            hostname=d.get('hostname'),
 7085            id=d.get('id'),
 7086            name=d.get('name'),
 7087            password=d.get('password'),
 7088            port=d.get('port'),
 7089            port_override=d.get('port_override'),
 7090            secret_store_id=d.get('secret_store_id'),
 7091            tags=d.get('tags'),
 7092            tls_required=d.get('tls_required'),
 7093            username=d.get('username'),
 7094        )
 7095
 7096
 7097class MongoLegacyHost:
 7098    __slots__ = [
 7099        'auth_database',
 7100        'bind_interface',
 7101        'egress_filter',
 7102        'healthy',
 7103        'hostname',
 7104        'id',
 7105        'name',
 7106        'password',
 7107        'port',
 7108        'port_override',
 7109        'replica_set',
 7110        'secret_store_id',
 7111        'tags',
 7112        'tls_required',
 7113        'username',
 7114    ]
 7115
 7116    def __init__(
 7117        self,
 7118        auth_database=None,
 7119        bind_interface=None,
 7120        egress_filter=None,
 7121        healthy=None,
 7122        hostname=None,
 7123        id=None,
 7124        name=None,
 7125        password=None,
 7126        port=None,
 7127        port_override=None,
 7128        replica_set=None,
 7129        secret_store_id=None,
 7130        tags=None,
 7131        tls_required=None,
 7132        username=None,
 7133    ):
 7134        self.auth_database = auth_database if auth_database is not None else ''
 7135        self.bind_interface = bind_interface if bind_interface is not None else ''
 7136        '''
 7137         Bind interface
 7138        '''
 7139        self.egress_filter = egress_filter if egress_filter is not None else ''
 7140        '''
 7141         A filter applied to the routing logic to pin datasource to nodes.
 7142        '''
 7143        self.healthy = healthy if healthy is not None else False
 7144        '''
 7145         True if the datasource is reachable and the credentials are valid.
 7146        '''
 7147        self.hostname = hostname if hostname is not None else ''
 7148        self.id = id if id is not None else ''
 7149        '''
 7150         Unique identifier of the Resource.
 7151        '''
 7152        self.name = name if name is not None else ''
 7153        '''
 7154         Unique human-readable name of the Resource.
 7155        '''
 7156        self.password = password if password is not None else ''
 7157        self.port = port if port is not None else 0
 7158        self.port_override = port_override if port_override is not None else 0
 7159        self.replica_set = replica_set if replica_set is not None else ''
 7160        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7161        '''
 7162         ID of the secret store containing credentials for this resource, if any.
 7163        '''
 7164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7165        '''
 7166         Tags is a map of key, value pairs.
 7167        '''
 7168        self.tls_required = tls_required if tls_required is not None else False
 7169        self.username = username if username is not None else ''
 7170
 7171    def __repr__(self):
 7172        return '<sdm.MongoLegacyHost ' + \
 7173            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7174            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7175            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7176            'healthy: ' + repr(self.healthy) + ' ' +\
 7177            'hostname: ' + repr(self.hostname) + ' ' +\
 7178            'id: ' + repr(self.id) + ' ' +\
 7179            'name: ' + repr(self.name) + ' ' +\
 7180            'password: ' + repr(self.password) + ' ' +\
 7181            'port: ' + repr(self.port) + ' ' +\
 7182            'port_override: ' + repr(self.port_override) + ' ' +\
 7183            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7184            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7185            'tags: ' + repr(self.tags) + ' ' +\
 7186            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7187            'username: ' + repr(self.username) + ' ' +\
 7188            '>'
 7189
 7190    def to_dict(self):
 7191        return {
 7192            'auth_database': self.auth_database,
 7193            'bind_interface': self.bind_interface,
 7194            'egress_filter': self.egress_filter,
 7195            'healthy': self.healthy,
 7196            'hostname': self.hostname,
 7197            'id': self.id,
 7198            'name': self.name,
 7199            'password': self.password,
 7200            'port': self.port,
 7201            'port_override': self.port_override,
 7202            'replica_set': self.replica_set,
 7203            'secret_store_id': self.secret_store_id,
 7204            'tags': self.tags,
 7205            'tls_required': self.tls_required,
 7206            'username': self.username,
 7207        }
 7208
 7209    @classmethod
 7210    def from_dict(cls, d):
 7211        return cls(
 7212            auth_database=d.get('auth_database'),
 7213            bind_interface=d.get('bind_interface'),
 7214            egress_filter=d.get('egress_filter'),
 7215            healthy=d.get('healthy'),
 7216            hostname=d.get('hostname'),
 7217            id=d.get('id'),
 7218            name=d.get('name'),
 7219            password=d.get('password'),
 7220            port=d.get('port'),
 7221            port_override=d.get('port_override'),
 7222            replica_set=d.get('replica_set'),
 7223            secret_store_id=d.get('secret_store_id'),
 7224            tags=d.get('tags'),
 7225            tls_required=d.get('tls_required'),
 7226            username=d.get('username'),
 7227        )
 7228
 7229
 7230class MongoLegacyReplicaset:
 7231    __slots__ = [
 7232        'auth_database',
 7233        'bind_interface',
 7234        'connect_to_replica',
 7235        'egress_filter',
 7236        'healthy',
 7237        'hostname',
 7238        'id',
 7239        'name',
 7240        'password',
 7241        'port',
 7242        'port_override',
 7243        'replica_set',
 7244        'secret_store_id',
 7245        'tags',
 7246        'tls_required',
 7247        'username',
 7248    ]
 7249
 7250    def __init__(
 7251        self,
 7252        auth_database=None,
 7253        bind_interface=None,
 7254        connect_to_replica=None,
 7255        egress_filter=None,
 7256        healthy=None,
 7257        hostname=None,
 7258        id=None,
 7259        name=None,
 7260        password=None,
 7261        port=None,
 7262        port_override=None,
 7263        replica_set=None,
 7264        secret_store_id=None,
 7265        tags=None,
 7266        tls_required=None,
 7267        username=None,
 7268    ):
 7269        self.auth_database = auth_database if auth_database is not None else ''
 7270        self.bind_interface = bind_interface if bind_interface is not None else ''
 7271        '''
 7272         Bind interface
 7273        '''
 7274        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7275        self.egress_filter = egress_filter if egress_filter is not None else ''
 7276        '''
 7277         A filter applied to the routing logic to pin datasource to nodes.
 7278        '''
 7279        self.healthy = healthy if healthy is not None else False
 7280        '''
 7281         True if the datasource is reachable and the credentials are valid.
 7282        '''
 7283        self.hostname = hostname if hostname is not None else ''
 7284        self.id = id if id is not None else ''
 7285        '''
 7286         Unique identifier of the Resource.
 7287        '''
 7288        self.name = name if name is not None else ''
 7289        '''
 7290         Unique human-readable name of the Resource.
 7291        '''
 7292        self.password = password if password is not None else ''
 7293        self.port = port if port is not None else 0
 7294        self.port_override = port_override if port_override is not None else 0
 7295        self.replica_set = replica_set if replica_set is not None else ''
 7296        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7297        '''
 7298         ID of the secret store containing credentials for this resource, if any.
 7299        '''
 7300        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7301        '''
 7302         Tags is a map of key, value pairs.
 7303        '''
 7304        self.tls_required = tls_required if tls_required is not None else False
 7305        self.username = username if username is not None else ''
 7306
 7307    def __repr__(self):
 7308        return '<sdm.MongoLegacyReplicaset ' + \
 7309            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7310            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7311            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7312            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7313            'healthy: ' + repr(self.healthy) + ' ' +\
 7314            'hostname: ' + repr(self.hostname) + ' ' +\
 7315            'id: ' + repr(self.id) + ' ' +\
 7316            'name: ' + repr(self.name) + ' ' +\
 7317            'password: ' + repr(self.password) + ' ' +\
 7318            'port: ' + repr(self.port) + ' ' +\
 7319            'port_override: ' + repr(self.port_override) + ' ' +\
 7320            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7321            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7322            'tags: ' + repr(self.tags) + ' ' +\
 7323            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7324            'username: ' + repr(self.username) + ' ' +\
 7325            '>'
 7326
 7327    def to_dict(self):
 7328        return {
 7329            'auth_database': self.auth_database,
 7330            'bind_interface': self.bind_interface,
 7331            'connect_to_replica': self.connect_to_replica,
 7332            'egress_filter': self.egress_filter,
 7333            'healthy': self.healthy,
 7334            'hostname': self.hostname,
 7335            'id': self.id,
 7336            'name': self.name,
 7337            'password': self.password,
 7338            'port': self.port,
 7339            'port_override': self.port_override,
 7340            'replica_set': self.replica_set,
 7341            'secret_store_id': self.secret_store_id,
 7342            'tags': self.tags,
 7343            'tls_required': self.tls_required,
 7344            'username': self.username,
 7345        }
 7346
 7347    @classmethod
 7348    def from_dict(cls, d):
 7349        return cls(
 7350            auth_database=d.get('auth_database'),
 7351            bind_interface=d.get('bind_interface'),
 7352            connect_to_replica=d.get('connect_to_replica'),
 7353            egress_filter=d.get('egress_filter'),
 7354            healthy=d.get('healthy'),
 7355            hostname=d.get('hostname'),
 7356            id=d.get('id'),
 7357            name=d.get('name'),
 7358            password=d.get('password'),
 7359            port=d.get('port'),
 7360            port_override=d.get('port_override'),
 7361            replica_set=d.get('replica_set'),
 7362            secret_store_id=d.get('secret_store_id'),
 7363            tags=d.get('tags'),
 7364            tls_required=d.get('tls_required'),
 7365            username=d.get('username'),
 7366        )
 7367
 7368
 7369class MongoReplicaSet:
 7370    '''
 7371    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7372    without a major version bump.
 7373    '''
 7374    __slots__ = [
 7375        'auth_database',
 7376        'bind_interface',
 7377        'connect_to_replica',
 7378        'egress_filter',
 7379        'healthy',
 7380        'hostname',
 7381        'id',
 7382        'name',
 7383        'password',
 7384        'port',
 7385        'port_override',
 7386        'replica_set',
 7387        'secret_store_id',
 7388        'tags',
 7389        'tls_required',
 7390        'username',
 7391    ]
 7392
 7393    def __init__(
 7394        self,
 7395        auth_database=None,
 7396        bind_interface=None,
 7397        connect_to_replica=None,
 7398        egress_filter=None,
 7399        healthy=None,
 7400        hostname=None,
 7401        id=None,
 7402        name=None,
 7403        password=None,
 7404        port=None,
 7405        port_override=None,
 7406        replica_set=None,
 7407        secret_store_id=None,
 7408        tags=None,
 7409        tls_required=None,
 7410        username=None,
 7411    ):
 7412        self.auth_database = auth_database if auth_database is not None else ''
 7413        self.bind_interface = bind_interface if bind_interface is not None else ''
 7414        '''
 7415         Bind interface
 7416        '''
 7417        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7418        self.egress_filter = egress_filter if egress_filter is not None else ''
 7419        '''
 7420         A filter applied to the routing logic to pin datasource to nodes.
 7421        '''
 7422        self.healthy = healthy if healthy is not None else False
 7423        '''
 7424         True if the datasource is reachable and the credentials are valid.
 7425        '''
 7426        self.hostname = hostname if hostname is not None else ''
 7427        self.id = id if id is not None else ''
 7428        '''
 7429         Unique identifier of the Resource.
 7430        '''
 7431        self.name = name if name is not None else ''
 7432        '''
 7433         Unique human-readable name of the Resource.
 7434        '''
 7435        self.password = password if password is not None else ''
 7436        self.port = port if port is not None else 0
 7437        self.port_override = port_override if port_override is not None else 0
 7438        self.replica_set = replica_set if replica_set is not None else ''
 7439        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7440        '''
 7441         ID of the secret store containing credentials for this resource, if any.
 7442        '''
 7443        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7444        '''
 7445         Tags is a map of key, value pairs.
 7446        '''
 7447        self.tls_required = tls_required if tls_required is not None else False
 7448        self.username = username if username is not None else ''
 7449
 7450    def __repr__(self):
 7451        return '<sdm.MongoReplicaSet ' + \
 7452            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7453            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7454            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7455            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7456            'healthy: ' + repr(self.healthy) + ' ' +\
 7457            'hostname: ' + repr(self.hostname) + ' ' +\
 7458            'id: ' + repr(self.id) + ' ' +\
 7459            'name: ' + repr(self.name) + ' ' +\
 7460            'password: ' + repr(self.password) + ' ' +\
 7461            'port: ' + repr(self.port) + ' ' +\
 7462            'port_override: ' + repr(self.port_override) + ' ' +\
 7463            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7464            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7465            'tags: ' + repr(self.tags) + ' ' +\
 7466            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7467            'username: ' + repr(self.username) + ' ' +\
 7468            '>'
 7469
 7470    def to_dict(self):
 7471        return {
 7472            'auth_database': self.auth_database,
 7473            'bind_interface': self.bind_interface,
 7474            'connect_to_replica': self.connect_to_replica,
 7475            'egress_filter': self.egress_filter,
 7476            'healthy': self.healthy,
 7477            'hostname': self.hostname,
 7478            'id': self.id,
 7479            'name': self.name,
 7480            'password': self.password,
 7481            'port': self.port,
 7482            'port_override': self.port_override,
 7483            'replica_set': self.replica_set,
 7484            'secret_store_id': self.secret_store_id,
 7485            'tags': self.tags,
 7486            'tls_required': self.tls_required,
 7487            'username': self.username,
 7488        }
 7489
 7490    @classmethod
 7491    def from_dict(cls, d):
 7492        return cls(
 7493            auth_database=d.get('auth_database'),
 7494            bind_interface=d.get('bind_interface'),
 7495            connect_to_replica=d.get('connect_to_replica'),
 7496            egress_filter=d.get('egress_filter'),
 7497            healthy=d.get('healthy'),
 7498            hostname=d.get('hostname'),
 7499            id=d.get('id'),
 7500            name=d.get('name'),
 7501            password=d.get('password'),
 7502            port=d.get('port'),
 7503            port_override=d.get('port_override'),
 7504            replica_set=d.get('replica_set'),
 7505            secret_store_id=d.get('secret_store_id'),
 7506            tags=d.get('tags'),
 7507            tls_required=d.get('tls_required'),
 7508            username=d.get('username'),
 7509        )
 7510
 7511
 7512class MongoShardedCluster:
 7513    '''
 7514    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 7515    without a major version bump.
 7516    '''
 7517    __slots__ = [
 7518        'auth_database',
 7519        'bind_interface',
 7520        'egress_filter',
 7521        'healthy',
 7522        'hostname',
 7523        'id',
 7524        'name',
 7525        'password',
 7526        'port_override',
 7527        'secret_store_id',
 7528        'tags',
 7529        'tls_required',
 7530        'username',
 7531    ]
 7532
 7533    def __init__(
 7534        self,
 7535        auth_database=None,
 7536        bind_interface=None,
 7537        egress_filter=None,
 7538        healthy=None,
 7539        hostname=None,
 7540        id=None,
 7541        name=None,
 7542        password=None,
 7543        port_override=None,
 7544        secret_store_id=None,
 7545        tags=None,
 7546        tls_required=None,
 7547        username=None,
 7548    ):
 7549        self.auth_database = auth_database if auth_database is not None else ''
 7550        self.bind_interface = bind_interface if bind_interface is not None else ''
 7551        '''
 7552         Bind interface
 7553        '''
 7554        self.egress_filter = egress_filter if egress_filter is not None else ''
 7555        '''
 7556         A filter applied to the routing logic to pin datasource to nodes.
 7557        '''
 7558        self.healthy = healthy if healthy is not None else False
 7559        '''
 7560         True if the datasource is reachable and the credentials are valid.
 7561        '''
 7562        self.hostname = hostname if hostname is not None else ''
 7563        self.id = id if id is not None else ''
 7564        '''
 7565         Unique identifier of the Resource.
 7566        '''
 7567        self.name = name if name is not None else ''
 7568        '''
 7569         Unique human-readable name of the Resource.
 7570        '''
 7571        self.password = password if password is not None else ''
 7572        self.port_override = port_override if port_override is not None else 0
 7573        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7574        '''
 7575         ID of the secret store containing credentials for this resource, if any.
 7576        '''
 7577        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7578        '''
 7579         Tags is a map of key, value pairs.
 7580        '''
 7581        self.tls_required = tls_required if tls_required is not None else False
 7582        self.username = username if username is not None else ''
 7583
 7584    def __repr__(self):
 7585        return '<sdm.MongoShardedCluster ' + \
 7586            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7588            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7589            'healthy: ' + repr(self.healthy) + ' ' +\
 7590            'hostname: ' + repr(self.hostname) + ' ' +\
 7591            'id: ' + repr(self.id) + ' ' +\
 7592            'name: ' + repr(self.name) + ' ' +\
 7593            'password: ' + repr(self.password) + ' ' +\
 7594            'port_override: ' + repr(self.port_override) + ' ' +\
 7595            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7596            'tags: ' + repr(self.tags) + ' ' +\
 7597            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7598            'username: ' + repr(self.username) + ' ' +\
 7599            '>'
 7600
 7601    def to_dict(self):
 7602        return {
 7603            'auth_database': self.auth_database,
 7604            'bind_interface': self.bind_interface,
 7605            'egress_filter': self.egress_filter,
 7606            'healthy': self.healthy,
 7607            'hostname': self.hostname,
 7608            'id': self.id,
 7609            'name': self.name,
 7610            'password': self.password,
 7611            'port_override': self.port_override,
 7612            'secret_store_id': self.secret_store_id,
 7613            'tags': self.tags,
 7614            'tls_required': self.tls_required,
 7615            'username': self.username,
 7616        }
 7617
 7618    @classmethod
 7619    def from_dict(cls, d):
 7620        return cls(
 7621            auth_database=d.get('auth_database'),
 7622            bind_interface=d.get('bind_interface'),
 7623            egress_filter=d.get('egress_filter'),
 7624            healthy=d.get('healthy'),
 7625            hostname=d.get('hostname'),
 7626            id=d.get('id'),
 7627            name=d.get('name'),
 7628            password=d.get('password'),
 7629            port_override=d.get('port_override'),
 7630            secret_store_id=d.get('secret_store_id'),
 7631            tags=d.get('tags'),
 7632            tls_required=d.get('tls_required'),
 7633            username=d.get('username'),
 7634        )
 7635
 7636
 7637class Mysql:
 7638    __slots__ = [
 7639        'bind_interface',
 7640        'database',
 7641        'egress_filter',
 7642        'healthy',
 7643        'hostname',
 7644        'id',
 7645        'name',
 7646        'password',
 7647        'port',
 7648        'port_override',
 7649        'secret_store_id',
 7650        'tags',
 7651        'username',
 7652    ]
 7653
 7654    def __init__(
 7655        self,
 7656        bind_interface=None,
 7657        database=None,
 7658        egress_filter=None,
 7659        healthy=None,
 7660        hostname=None,
 7661        id=None,
 7662        name=None,
 7663        password=None,
 7664        port=None,
 7665        port_override=None,
 7666        secret_store_id=None,
 7667        tags=None,
 7668        username=None,
 7669    ):
 7670        self.bind_interface = bind_interface if bind_interface is not None else ''
 7671        '''
 7672         Bind interface
 7673        '''
 7674        self.database = database if database is not None else ''
 7675        self.egress_filter = egress_filter if egress_filter is not None else ''
 7676        '''
 7677         A filter applied to the routing logic to pin datasource to nodes.
 7678        '''
 7679        self.healthy = healthy if healthy is not None else False
 7680        '''
 7681         True if the datasource is reachable and the credentials are valid.
 7682        '''
 7683        self.hostname = hostname if hostname is not None else ''
 7684        self.id = id if id is not None else ''
 7685        '''
 7686         Unique identifier of the Resource.
 7687        '''
 7688        self.name = name if name is not None else ''
 7689        '''
 7690         Unique human-readable name of the Resource.
 7691        '''
 7692        self.password = password if password is not None else ''
 7693        self.port = port if port is not None else 0
 7694        self.port_override = port_override if port_override is not None else 0
 7695        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7696        '''
 7697         ID of the secret store containing credentials for this resource, if any.
 7698        '''
 7699        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7700        '''
 7701         Tags is a map of key, value pairs.
 7702        '''
 7703        self.username = username if username is not None else ''
 7704
 7705    def __repr__(self):
 7706        return '<sdm.Mysql ' + \
 7707            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7708            'database: ' + repr(self.database) + ' ' +\
 7709            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7710            'healthy: ' + repr(self.healthy) + ' ' +\
 7711            'hostname: ' + repr(self.hostname) + ' ' +\
 7712            'id: ' + repr(self.id) + ' ' +\
 7713            'name: ' + repr(self.name) + ' ' +\
 7714            'password: ' + repr(self.password) + ' ' +\
 7715            'port: ' + repr(self.port) + ' ' +\
 7716            'port_override: ' + repr(self.port_override) + ' ' +\
 7717            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7718            'tags: ' + repr(self.tags) + ' ' +\
 7719            'username: ' + repr(self.username) + ' ' +\
 7720            '>'
 7721
 7722    def to_dict(self):
 7723        return {
 7724            'bind_interface': self.bind_interface,
 7725            'database': self.database,
 7726            'egress_filter': self.egress_filter,
 7727            'healthy': self.healthy,
 7728            'hostname': self.hostname,
 7729            'id': self.id,
 7730            'name': self.name,
 7731            'password': self.password,
 7732            'port': self.port,
 7733            'port_override': self.port_override,
 7734            'secret_store_id': self.secret_store_id,
 7735            'tags': self.tags,
 7736            'username': self.username,
 7737        }
 7738
 7739    @classmethod
 7740    def from_dict(cls, d):
 7741        return cls(
 7742            bind_interface=d.get('bind_interface'),
 7743            database=d.get('database'),
 7744            egress_filter=d.get('egress_filter'),
 7745            healthy=d.get('healthy'),
 7746            hostname=d.get('hostname'),
 7747            id=d.get('id'),
 7748            name=d.get('name'),
 7749            password=d.get('password'),
 7750            port=d.get('port'),
 7751            port_override=d.get('port_override'),
 7752            secret_store_id=d.get('secret_store_id'),
 7753            tags=d.get('tags'),
 7754            username=d.get('username'),
 7755        )
 7756
 7757
 7758class Neptune:
 7759    __slots__ = [
 7760        'bind_interface',
 7761        'egress_filter',
 7762        'endpoint',
 7763        'healthy',
 7764        'id',
 7765        'name',
 7766        'port',
 7767        'port_override',
 7768        'secret_store_id',
 7769        'tags',
 7770    ]
 7771
 7772    def __init__(
 7773        self,
 7774        bind_interface=None,
 7775        egress_filter=None,
 7776        endpoint=None,
 7777        healthy=None,
 7778        id=None,
 7779        name=None,
 7780        port=None,
 7781        port_override=None,
 7782        secret_store_id=None,
 7783        tags=None,
 7784    ):
 7785        self.bind_interface = bind_interface if bind_interface is not None else ''
 7786        '''
 7787         Bind interface
 7788        '''
 7789        self.egress_filter = egress_filter if egress_filter is not None else ''
 7790        '''
 7791         A filter applied to the routing logic to pin datasource to nodes.
 7792        '''
 7793        self.endpoint = endpoint if endpoint is not None else ''
 7794        self.healthy = healthy if healthy is not None else False
 7795        '''
 7796         True if the datasource is reachable and the credentials are valid.
 7797        '''
 7798        self.id = id if id is not None else ''
 7799        '''
 7800         Unique identifier of the Resource.
 7801        '''
 7802        self.name = name if name is not None else ''
 7803        '''
 7804         Unique human-readable name of the Resource.
 7805        '''
 7806        self.port = port if port is not None else 0
 7807        self.port_override = port_override if port_override is not None else 0
 7808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7809        '''
 7810         ID of the secret store containing credentials for this resource, if any.
 7811        '''
 7812        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7813        '''
 7814         Tags is a map of key, value pairs.
 7815        '''
 7816
 7817    def __repr__(self):
 7818        return '<sdm.Neptune ' + \
 7819            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7820            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7821            'endpoint: ' + repr(self.endpoint) + ' ' +\
 7822            'healthy: ' + repr(self.healthy) + ' ' +\
 7823            'id: ' + repr(self.id) + ' ' +\
 7824            'name: ' + repr(self.name) + ' ' +\
 7825            'port: ' + repr(self.port) + ' ' +\
 7826            'port_override: ' + repr(self.port_override) + ' ' +\
 7827            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7828            'tags: ' + repr(self.tags) + ' ' +\
 7829            '>'
 7830
 7831    def to_dict(self):
 7832        return {
 7833            'bind_interface': self.bind_interface,
 7834            'egress_filter': self.egress_filter,
 7835            'endpoint': self.endpoint,
 7836            'healthy': self.healthy,
 7837            'id': self.id,
 7838            'name': self.name,
 7839            'port': self.port,
 7840            'port_override': self.port_override,
 7841            'secret_store_id': self.secret_store_id,
 7842            'tags': self.tags,
 7843        }
 7844
 7845    @classmethod
 7846    def from_dict(cls, d):
 7847        return cls(
 7848            bind_interface=d.get('bind_interface'),
 7849            egress_filter=d.get('egress_filter'),
 7850            endpoint=d.get('endpoint'),
 7851            healthy=d.get('healthy'),
 7852            id=d.get('id'),
 7853            name=d.get('name'),
 7854            port=d.get('port'),
 7855            port_override=d.get('port_override'),
 7856            secret_store_id=d.get('secret_store_id'),
 7857            tags=d.get('tags'),
 7858        )
 7859
 7860
 7861class NeptuneIAM:
 7862    __slots__ = [
 7863        'access_key',
 7864        'bind_interface',
 7865        'egress_filter',
 7866        'endpoint',
 7867        'healthy',
 7868        'id',
 7869        'name',
 7870        'port',
 7871        'port_override',
 7872        'region',
 7873        'role_arn',
 7874        'role_external_id',
 7875        'secret_access_key',
 7876        'secret_store_id',
 7877        'tags',
 7878    ]
 7879
 7880    def __init__(
 7881        self,
 7882        access_key=None,
 7883        bind_interface=None,
 7884        egress_filter=None,
 7885        endpoint=None,
 7886        healthy=None,
 7887        id=None,
 7888        name=None,
 7889        port=None,
 7890        port_override=None,
 7891        region=None,
 7892        role_arn=None,
 7893        role_external_id=None,
 7894        secret_access_key=None,
 7895        secret_store_id=None,
 7896        tags=None,
 7897    ):
 7898        self.access_key = access_key if access_key is not None else ''
 7899        self.bind_interface = bind_interface if bind_interface is not None else ''
 7900        '''
 7901         Bind interface
 7902        '''
 7903        self.egress_filter = egress_filter if egress_filter is not None else ''
 7904        '''
 7905         A filter applied to the routing logic to pin datasource to nodes.
 7906        '''
 7907        self.endpoint = endpoint if endpoint is not None else ''
 7908        self.healthy = healthy if healthy is not None else False
 7909        '''
 7910         True if the datasource is reachable and the credentials are valid.
 7911        '''
 7912        self.id = id if id is not None else ''
 7913        '''
 7914         Unique identifier of the Resource.
 7915        '''
 7916        self.name = name if name is not None else ''
 7917        '''
 7918         Unique human-readable name of the Resource.
 7919        '''
 7920        self.port = port if port is not None else 0
 7921        self.port_override = port_override if port_override is not None else 0
 7922        self.region = region if region is not None else ''
 7923        self.role_arn = role_arn if role_arn is not None else ''
 7924        self.role_external_id = role_external_id if role_external_id is not None else ''
 7925        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 7926        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7927        '''
 7928         ID of the secret store containing credentials for this resource, if any.
 7929        '''
 7930        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7931        '''
 7932         Tags is a map of key, value pairs.
 7933        '''
 7934
 7935    def __repr__(self):
 7936        return '<sdm.NeptuneIAM ' + \
 7937            'access_key: ' + repr(self.access_key) + ' ' +\
 7938            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7939            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7940            'endpoint: ' + repr(self.endpoint) + ' ' +\
 7941            'healthy: ' + repr(self.healthy) + ' ' +\
 7942            'id: ' + repr(self.id) + ' ' +\
 7943            'name: ' + repr(self.name) + ' ' +\
 7944            'port: ' + repr(self.port) + ' ' +\
 7945            'port_override: ' + repr(self.port_override) + ' ' +\
 7946            'region: ' + repr(self.region) + ' ' +\
 7947            'role_arn: ' + repr(self.role_arn) + ' ' +\
 7948            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 7949            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 7950            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7951            'tags: ' + repr(self.tags) + ' ' +\
 7952            '>'
 7953
 7954    def to_dict(self):
 7955        return {
 7956            'access_key': self.access_key,
 7957            'bind_interface': self.bind_interface,
 7958            'egress_filter': self.egress_filter,
 7959            'endpoint': self.endpoint,
 7960            'healthy': self.healthy,
 7961            'id': self.id,
 7962            'name': self.name,
 7963            'port': self.port,
 7964            'port_override': self.port_override,
 7965            'region': self.region,
 7966            'role_arn': self.role_arn,
 7967            'role_external_id': self.role_external_id,
 7968            'secret_access_key': self.secret_access_key,
 7969            'secret_store_id': self.secret_store_id,
 7970            'tags': self.tags,
 7971        }
 7972
 7973    @classmethod
 7974    def from_dict(cls, d):
 7975        return cls(
 7976            access_key=d.get('access_key'),
 7977            bind_interface=d.get('bind_interface'),
 7978            egress_filter=d.get('egress_filter'),
 7979            endpoint=d.get('endpoint'),
 7980            healthy=d.get('healthy'),
 7981            id=d.get('id'),
 7982            name=d.get('name'),
 7983            port=d.get('port'),
 7984            port_override=d.get('port_override'),
 7985            region=d.get('region'),
 7986            role_arn=d.get('role_arn'),
 7987            role_external_id=d.get('role_external_id'),
 7988            secret_access_key=d.get('secret_access_key'),
 7989            secret_store_id=d.get('secret_store_id'),
 7990            tags=d.get('tags'),
 7991        )
 7992
 7993
 7994class NodeCreateResponse:
 7995    '''
 7996         NodeCreateResponse reports how the Nodes were created in the system.
 7997    '''
 7998    __slots__ = [
 7999        'meta',
 8000        'node',
 8001        'rate_limit',
 8002        'token',
 8003    ]
 8004
 8005    def __init__(
 8006        self,
 8007        meta=None,
 8008        node=None,
 8009        rate_limit=None,
 8010        token=None,
 8011    ):
 8012        self.meta = meta if meta is not None else None
 8013        '''
 8014         Reserved for future use.
 8015        '''
 8016        self.node = node if node is not None else None
 8017        '''
 8018         The created Node.
 8019        '''
 8020        self.rate_limit = rate_limit if rate_limit is not None else None
 8021        '''
 8022         Rate limit information.
 8023        '''
 8024        self.token = token if token is not None else ''
 8025        '''
 8026         The auth token generated for the Node. The Node will use this token to
 8027         authenticate with the strongDM API.
 8028        '''
 8029
 8030    def __repr__(self):
 8031        return '<sdm.NodeCreateResponse ' + \
 8032            'meta: ' + repr(self.meta) + ' ' +\
 8033            'node: ' + repr(self.node) + ' ' +\
 8034            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8035            'token: ' + repr(self.token) + ' ' +\
 8036            '>'
 8037
 8038    def to_dict(self):
 8039        return {
 8040            'meta': self.meta,
 8041            'node': self.node,
 8042            'rate_limit': self.rate_limit,
 8043            'token': self.token,
 8044        }
 8045
 8046    @classmethod
 8047    def from_dict(cls, d):
 8048        return cls(
 8049            meta=d.get('meta'),
 8050            node=d.get('node'),
 8051            rate_limit=d.get('rate_limit'),
 8052            token=d.get('token'),
 8053        )
 8054
 8055
 8056class NodeDeleteResponse:
 8057    '''
 8058         NodeDeleteResponse returns information about a Node that was deleted.
 8059    '''
 8060    __slots__ = [
 8061        'meta',
 8062        'rate_limit',
 8063    ]
 8064
 8065    def __init__(
 8066        self,
 8067        meta=None,
 8068        rate_limit=None,
 8069    ):
 8070        self.meta = meta if meta is not None else None
 8071        '''
 8072         Reserved for future use.
 8073        '''
 8074        self.rate_limit = rate_limit if rate_limit is not None else None
 8075        '''
 8076         Rate limit information.
 8077        '''
 8078
 8079    def __repr__(self):
 8080        return '<sdm.NodeDeleteResponse ' + \
 8081            'meta: ' + repr(self.meta) + ' ' +\
 8082            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8083            '>'
 8084
 8085    def to_dict(self):
 8086        return {
 8087            'meta': self.meta,
 8088            'rate_limit': self.rate_limit,
 8089        }
 8090
 8091    @classmethod
 8092    def from_dict(cls, d):
 8093        return cls(
 8094            meta=d.get('meta'),
 8095            rate_limit=d.get('rate_limit'),
 8096        )
 8097
 8098
 8099class NodeGetResponse:
 8100    '''
 8101         NodeGetResponse returns a requested Node.
 8102    '''
 8103    __slots__ = [
 8104        'meta',
 8105        'node',
 8106        'rate_limit',
 8107    ]
 8108
 8109    def __init__(
 8110        self,
 8111        meta=None,
 8112        node=None,
 8113        rate_limit=None,
 8114    ):
 8115        self.meta = meta if meta is not None else None
 8116        '''
 8117         Reserved for future use.
 8118        '''
 8119        self.node = node if node is not None else None
 8120        '''
 8121         The requested Node.
 8122        '''
 8123        self.rate_limit = rate_limit if rate_limit is not None else None
 8124        '''
 8125         Rate limit information.
 8126        '''
 8127
 8128    def __repr__(self):
 8129        return '<sdm.NodeGetResponse ' + \
 8130            'meta: ' + repr(self.meta) + ' ' +\
 8131            'node: ' + repr(self.node) + ' ' +\
 8132            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8133            '>'
 8134
 8135    def to_dict(self):
 8136        return {
 8137            'meta': self.meta,
 8138            'node': self.node,
 8139            'rate_limit': self.rate_limit,
 8140        }
 8141
 8142    @classmethod
 8143    def from_dict(cls, d):
 8144        return cls(
 8145            meta=d.get('meta'),
 8146            node=d.get('node'),
 8147            rate_limit=d.get('rate_limit'),
 8148        )
 8149
 8150
 8151class NodeUpdateResponse:
 8152    '''
 8153         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8154     a NodeUpdateRequest.
 8155    '''
 8156    __slots__ = [
 8157        'meta',
 8158        'node',
 8159        'rate_limit',
 8160    ]
 8161
 8162    def __init__(
 8163        self,
 8164        meta=None,
 8165        node=None,
 8166        rate_limit=None,
 8167    ):
 8168        self.meta = meta if meta is not None else None
 8169        '''
 8170         Reserved for future use.
 8171        '''
 8172        self.node = node if node is not None else None
 8173        '''
 8174         The updated Node.
 8175        '''
 8176        self.rate_limit = rate_limit if rate_limit is not None else None
 8177        '''
 8178         Rate limit information.
 8179        '''
 8180
 8181    def __repr__(self):
 8182        return '<sdm.NodeUpdateResponse ' + \
 8183            'meta: ' + repr(self.meta) + ' ' +\
 8184            'node: ' + repr(self.node) + ' ' +\
 8185            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8186            '>'
 8187
 8188    def to_dict(self):
 8189        return {
 8190            'meta': self.meta,
 8191            'node': self.node,
 8192            'rate_limit': self.rate_limit,
 8193        }
 8194
 8195    @classmethod
 8196    def from_dict(cls, d):
 8197        return cls(
 8198            meta=d.get('meta'),
 8199            node=d.get('node'),
 8200            rate_limit=d.get('rate_limit'),
 8201        )
 8202
 8203
 8204class Oracle:
 8205    '''
 8206    Oracle is currently unstable, and its API may change, or it may be removed,
 8207    without a major version bump.
 8208    '''
 8209    __slots__ = [
 8210        'bind_interface',
 8211        'database',
 8212        'egress_filter',
 8213        'healthy',
 8214        'hostname',
 8215        'id',
 8216        'name',
 8217        'password',
 8218        'port',
 8219        'port_override',
 8220        'secret_store_id',
 8221        'tags',
 8222        'tls_required',
 8223        'username',
 8224    ]
 8225
 8226    def __init__(
 8227        self,
 8228        bind_interface=None,
 8229        database=None,
 8230        egress_filter=None,
 8231        healthy=None,
 8232        hostname=None,
 8233        id=None,
 8234        name=None,
 8235        password=None,
 8236        port=None,
 8237        port_override=None,
 8238        secret_store_id=None,
 8239        tags=None,
 8240        tls_required=None,
 8241        username=None,
 8242    ):
 8243        self.bind_interface = bind_interface if bind_interface is not None else ''
 8244        '''
 8245         Bind interface
 8246        '''
 8247        self.database = database if database is not None else ''
 8248        self.egress_filter = egress_filter if egress_filter is not None else ''
 8249        '''
 8250         A filter applied to the routing logic to pin datasource to nodes.
 8251        '''
 8252        self.healthy = healthy if healthy is not None else False
 8253        '''
 8254         True if the datasource is reachable and the credentials are valid.
 8255        '''
 8256        self.hostname = hostname if hostname is not None else ''
 8257        self.id = id if id is not None else ''
 8258        '''
 8259         Unique identifier of the Resource.
 8260        '''
 8261        self.name = name if name is not None else ''
 8262        '''
 8263         Unique human-readable name of the Resource.
 8264        '''
 8265        self.password = password if password is not None else ''
 8266        self.port = port if port is not None else 0
 8267        self.port_override = port_override if port_override is not None else 0
 8268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8269        '''
 8270         ID of the secret store containing credentials for this resource, if any.
 8271        '''
 8272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8273        '''
 8274         Tags is a map of key, value pairs.
 8275        '''
 8276        self.tls_required = tls_required if tls_required is not None else False
 8277        self.username = username if username is not None else ''
 8278
 8279    def __repr__(self):
 8280        return '<sdm.Oracle ' + \
 8281            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8282            'database: ' + repr(self.database) + ' ' +\
 8283            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8284            'healthy: ' + repr(self.healthy) + ' ' +\
 8285            'hostname: ' + repr(self.hostname) + ' ' +\
 8286            'id: ' + repr(self.id) + ' ' +\
 8287            'name: ' + repr(self.name) + ' ' +\
 8288            'password: ' + repr(self.password) + ' ' +\
 8289            'port: ' + repr(self.port) + ' ' +\
 8290            'port_override: ' + repr(self.port_override) + ' ' +\
 8291            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8292            'tags: ' + repr(self.tags) + ' ' +\
 8293            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8294            'username: ' + repr(self.username) + ' ' +\
 8295            '>'
 8296
 8297    def to_dict(self):
 8298        return {
 8299            'bind_interface': self.bind_interface,
 8300            'database': self.database,
 8301            'egress_filter': self.egress_filter,
 8302            'healthy': self.healthy,
 8303            'hostname': self.hostname,
 8304            'id': self.id,
 8305            'name': self.name,
 8306            'password': self.password,
 8307            'port': self.port,
 8308            'port_override': self.port_override,
 8309            'secret_store_id': self.secret_store_id,
 8310            'tags': self.tags,
 8311            'tls_required': self.tls_required,
 8312            'username': self.username,
 8313        }
 8314
 8315    @classmethod
 8316    def from_dict(cls, d):
 8317        return cls(
 8318            bind_interface=d.get('bind_interface'),
 8319            database=d.get('database'),
 8320            egress_filter=d.get('egress_filter'),
 8321            healthy=d.get('healthy'),
 8322            hostname=d.get('hostname'),
 8323            id=d.get('id'),
 8324            name=d.get('name'),
 8325            password=d.get('password'),
 8326            port=d.get('port'),
 8327            port_override=d.get('port_override'),
 8328            secret_store_id=d.get('secret_store_id'),
 8329            tags=d.get('tags'),
 8330            tls_required=d.get('tls_required'),
 8331            username=d.get('username'),
 8332        )
 8333
 8334
 8335class Postgres:
 8336    __slots__ = [
 8337        'bind_interface',
 8338        'database',
 8339        'egress_filter',
 8340        'healthy',
 8341        'hostname',
 8342        'id',
 8343        'name',
 8344        'override_database',
 8345        'password',
 8346        'port',
 8347        'port_override',
 8348        'secret_store_id',
 8349        'tags',
 8350        'username',
 8351    ]
 8352
 8353    def __init__(
 8354        self,
 8355        bind_interface=None,
 8356        database=None,
 8357        egress_filter=None,
 8358        healthy=None,
 8359        hostname=None,
 8360        id=None,
 8361        name=None,
 8362        override_database=None,
 8363        password=None,
 8364        port=None,
 8365        port_override=None,
 8366        secret_store_id=None,
 8367        tags=None,
 8368        username=None,
 8369    ):
 8370        self.bind_interface = bind_interface if bind_interface is not None else ''
 8371        '''
 8372         Bind interface
 8373        '''
 8374        self.database = database if database is not None else ''
 8375        self.egress_filter = egress_filter if egress_filter is not None else ''
 8376        '''
 8377         A filter applied to the routing logic to pin datasource to nodes.
 8378        '''
 8379        self.healthy = healthy if healthy is not None else False
 8380        '''
 8381         True if the datasource is reachable and the credentials are valid.
 8382        '''
 8383        self.hostname = hostname if hostname is not None else ''
 8384        self.id = id if id is not None else ''
 8385        '''
 8386         Unique identifier of the Resource.
 8387        '''
 8388        self.name = name if name is not None else ''
 8389        '''
 8390         Unique human-readable name of the Resource.
 8391        '''
 8392        self.override_database = override_database if override_database is not None else False
 8393        self.password = password if password is not None else ''
 8394        self.port = port if port is not None else 0
 8395        self.port_override = port_override if port_override is not None else 0
 8396        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8397        '''
 8398         ID of the secret store containing credentials for this resource, if any.
 8399        '''
 8400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8401        '''
 8402         Tags is a map of key, value pairs.
 8403        '''
 8404        self.username = username if username is not None else ''
 8405
 8406    def __repr__(self):
 8407        return '<sdm.Postgres ' + \
 8408            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8409            'database: ' + repr(self.database) + ' ' +\
 8410            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8411            'healthy: ' + repr(self.healthy) + ' ' +\
 8412            'hostname: ' + repr(self.hostname) + ' ' +\
 8413            'id: ' + repr(self.id) + ' ' +\
 8414            'name: ' + repr(self.name) + ' ' +\
 8415            'override_database: ' + repr(self.override_database) + ' ' +\
 8416            'password: ' + repr(self.password) + ' ' +\
 8417            'port: ' + repr(self.port) + ' ' +\
 8418            'port_override: ' + repr(self.port_override) + ' ' +\
 8419            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8420            'tags: ' + repr(self.tags) + ' ' +\
 8421            'username: ' + repr(self.username) + ' ' +\
 8422            '>'
 8423
 8424    def to_dict(self):
 8425        return {
 8426            'bind_interface': self.bind_interface,
 8427            'database': self.database,
 8428            'egress_filter': self.egress_filter,
 8429            'healthy': self.healthy,
 8430            'hostname': self.hostname,
 8431            'id': self.id,
 8432            'name': self.name,
 8433            'override_database': self.override_database,
 8434            'password': self.password,
 8435            'port': self.port,
 8436            'port_override': self.port_override,
 8437            'secret_store_id': self.secret_store_id,
 8438            'tags': self.tags,
 8439            'username': self.username,
 8440        }
 8441
 8442    @classmethod
 8443    def from_dict(cls, d):
 8444        return cls(
 8445            bind_interface=d.get('bind_interface'),
 8446            database=d.get('database'),
 8447            egress_filter=d.get('egress_filter'),
 8448            healthy=d.get('healthy'),
 8449            hostname=d.get('hostname'),
 8450            id=d.get('id'),
 8451            name=d.get('name'),
 8452            override_database=d.get('override_database'),
 8453            password=d.get('password'),
 8454            port=d.get('port'),
 8455            port_override=d.get('port_override'),
 8456            secret_store_id=d.get('secret_store_id'),
 8457            tags=d.get('tags'),
 8458            username=d.get('username'),
 8459        )
 8460
 8461
 8462class Presto:
 8463    __slots__ = [
 8464        'bind_interface',
 8465        'database',
 8466        'egress_filter',
 8467        'healthy',
 8468        'hostname',
 8469        'id',
 8470        'name',
 8471        'password',
 8472        'port',
 8473        'port_override',
 8474        'secret_store_id',
 8475        'tags',
 8476        'tls_required',
 8477        'username',
 8478    ]
 8479
 8480    def __init__(
 8481        self,
 8482        bind_interface=None,
 8483        database=None,
 8484        egress_filter=None,
 8485        healthy=None,
 8486        hostname=None,
 8487        id=None,
 8488        name=None,
 8489        password=None,
 8490        port=None,
 8491        port_override=None,
 8492        secret_store_id=None,
 8493        tags=None,
 8494        tls_required=None,
 8495        username=None,
 8496    ):
 8497        self.bind_interface = bind_interface if bind_interface is not None else ''
 8498        '''
 8499         Bind interface
 8500        '''
 8501        self.database = database if database is not None else ''
 8502        self.egress_filter = egress_filter if egress_filter is not None else ''
 8503        '''
 8504         A filter applied to the routing logic to pin datasource to nodes.
 8505        '''
 8506        self.healthy = healthy if healthy is not None else False
 8507        '''
 8508         True if the datasource is reachable and the credentials are valid.
 8509        '''
 8510        self.hostname = hostname if hostname is not None else ''
 8511        self.id = id if id is not None else ''
 8512        '''
 8513         Unique identifier of the Resource.
 8514        '''
 8515        self.name = name if name is not None else ''
 8516        '''
 8517         Unique human-readable name of the Resource.
 8518        '''
 8519        self.password = password if password is not None else ''
 8520        self.port = port if port is not None else 0
 8521        self.port_override = port_override if port_override is not None else 0
 8522        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8523        '''
 8524         ID of the secret store containing credentials for this resource, if any.
 8525        '''
 8526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8527        '''
 8528         Tags is a map of key, value pairs.
 8529        '''
 8530        self.tls_required = tls_required if tls_required is not None else False
 8531        self.username = username if username is not None else ''
 8532
 8533    def __repr__(self):
 8534        return '<sdm.Presto ' + \
 8535            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8536            'database: ' + repr(self.database) + ' ' +\
 8537            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8538            'healthy: ' + repr(self.healthy) + ' ' +\
 8539            'hostname: ' + repr(self.hostname) + ' ' +\
 8540            'id: ' + repr(self.id) + ' ' +\
 8541            'name: ' + repr(self.name) + ' ' +\
 8542            'password: ' + repr(self.password) + ' ' +\
 8543            'port: ' + repr(self.port) + ' ' +\
 8544            'port_override: ' + repr(self.port_override) + ' ' +\
 8545            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8546            'tags: ' + repr(self.tags) + ' ' +\
 8547            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8548            'username: ' + repr(self.username) + ' ' +\
 8549            '>'
 8550
 8551    def to_dict(self):
 8552        return {
 8553            'bind_interface': self.bind_interface,
 8554            'database': self.database,
 8555            'egress_filter': self.egress_filter,
 8556            'healthy': self.healthy,
 8557            'hostname': self.hostname,
 8558            'id': self.id,
 8559            'name': self.name,
 8560            'password': self.password,
 8561            'port': self.port,
 8562            'port_override': self.port_override,
 8563            'secret_store_id': self.secret_store_id,
 8564            'tags': self.tags,
 8565            'tls_required': self.tls_required,
 8566            'username': self.username,
 8567        }
 8568
 8569    @classmethod
 8570    def from_dict(cls, d):
 8571        return cls(
 8572            bind_interface=d.get('bind_interface'),
 8573            database=d.get('database'),
 8574            egress_filter=d.get('egress_filter'),
 8575            healthy=d.get('healthy'),
 8576            hostname=d.get('hostname'),
 8577            id=d.get('id'),
 8578            name=d.get('name'),
 8579            password=d.get('password'),
 8580            port=d.get('port'),
 8581            port_override=d.get('port_override'),
 8582            secret_store_id=d.get('secret_store_id'),
 8583            tags=d.get('tags'),
 8584            tls_required=d.get('tls_required'),
 8585            username=d.get('username'),
 8586        )
 8587
 8588
 8589class RDP:
 8590    __slots__ = [
 8591        'bind_interface',
 8592        'downgrade_nla_connections',
 8593        'egress_filter',
 8594        'healthy',
 8595        'hostname',
 8596        'id',
 8597        'name',
 8598        'password',
 8599        'port',
 8600        'port_override',
 8601        'secret_store_id',
 8602        'tags',
 8603        'username',
 8604    ]
 8605
 8606    def __init__(
 8607        self,
 8608        bind_interface=None,
 8609        downgrade_nla_connections=None,
 8610        egress_filter=None,
 8611        healthy=None,
 8612        hostname=None,
 8613        id=None,
 8614        name=None,
 8615        password=None,
 8616        port=None,
 8617        port_override=None,
 8618        secret_store_id=None,
 8619        tags=None,
 8620        username=None,
 8621    ):
 8622        self.bind_interface = bind_interface if bind_interface is not None else ''
 8623        '''
 8624         Bind interface
 8625        '''
 8626        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 8627        self.egress_filter = egress_filter if egress_filter is not None else ''
 8628        '''
 8629         A filter applied to the routing logic to pin datasource to nodes.
 8630        '''
 8631        self.healthy = healthy if healthy is not None else False
 8632        '''
 8633         True if the datasource is reachable and the credentials are valid.
 8634        '''
 8635        self.hostname = hostname if hostname is not None else ''
 8636        self.id = id if id is not None else ''
 8637        '''
 8638         Unique identifier of the Resource.
 8639        '''
 8640        self.name = name if name is not None else ''
 8641        '''
 8642         Unique human-readable name of the Resource.
 8643        '''
 8644        self.password = password if password is not None else ''
 8645        self.port = port if port is not None else 0
 8646        self.port_override = port_override if port_override is not None else 0
 8647        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8648        '''
 8649         ID of the secret store containing credentials for this resource, if any.
 8650        '''
 8651        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8652        '''
 8653         Tags is a map of key, value pairs.
 8654        '''
 8655        self.username = username if username is not None else ''
 8656
 8657    def __repr__(self):
 8658        return '<sdm.RDP ' + \
 8659            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8660            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 8661            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8662            'healthy: ' + repr(self.healthy) + ' ' +\
 8663            'hostname: ' + repr(self.hostname) + ' ' +\
 8664            'id: ' + repr(self.id) + ' ' +\
 8665            'name: ' + repr(self.name) + ' ' +\
 8666            'password: ' + repr(self.password) + ' ' +\
 8667            'port: ' + repr(self.port) + ' ' +\
 8668            'port_override: ' + repr(self.port_override) + ' ' +\
 8669            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8670            'tags: ' + repr(self.tags) + ' ' +\
 8671            'username: ' + repr(self.username) + ' ' +\
 8672            '>'
 8673
 8674    def to_dict(self):
 8675        return {
 8676            'bind_interface': self.bind_interface,
 8677            'downgrade_nla_connections': self.downgrade_nla_connections,
 8678            'egress_filter': self.egress_filter,
 8679            'healthy': self.healthy,
 8680            'hostname': self.hostname,
 8681            'id': self.id,
 8682            'name': self.name,
 8683            'password': self.password,
 8684            'port': self.port,
 8685            'port_override': self.port_override,
 8686            'secret_store_id': self.secret_store_id,
 8687            'tags': self.tags,
 8688            'username': self.username,
 8689        }
 8690
 8691    @classmethod
 8692    def from_dict(cls, d):
 8693        return cls(
 8694            bind_interface=d.get('bind_interface'),
 8695            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 8696            egress_filter=d.get('egress_filter'),
 8697            healthy=d.get('healthy'),
 8698            hostname=d.get('hostname'),
 8699            id=d.get('id'),
 8700            name=d.get('name'),
 8701            password=d.get('password'),
 8702            port=d.get('port'),
 8703            port_override=d.get('port_override'),
 8704            secret_store_id=d.get('secret_store_id'),
 8705            tags=d.get('tags'),
 8706            username=d.get('username'),
 8707        )
 8708
 8709
 8710class RabbitMQAMQP091:
 8711    __slots__ = [
 8712        'bind_interface',
 8713        'egress_filter',
 8714        'healthy',
 8715        'hostname',
 8716        'id',
 8717        'name',
 8718        'password',
 8719        'port',
 8720        'port_override',
 8721        'secret_store_id',
 8722        'tags',
 8723        'tls_required',
 8724        'username',
 8725    ]
 8726
 8727    def __init__(
 8728        self,
 8729        bind_interface=None,
 8730        egress_filter=None,
 8731        healthy=None,
 8732        hostname=None,
 8733        id=None,
 8734        name=None,
 8735        password=None,
 8736        port=None,
 8737        port_override=None,
 8738        secret_store_id=None,
 8739        tags=None,
 8740        tls_required=None,
 8741        username=None,
 8742    ):
 8743        self.bind_interface = bind_interface if bind_interface is not None else ''
 8744        '''
 8745         Bind interface
 8746        '''
 8747        self.egress_filter = egress_filter if egress_filter is not None else ''
 8748        '''
 8749         A filter applied to the routing logic to pin datasource to nodes.
 8750        '''
 8751        self.healthy = healthy if healthy is not None else False
 8752        '''
 8753         True if the datasource is reachable and the credentials are valid.
 8754        '''
 8755        self.hostname = hostname if hostname is not None else ''
 8756        self.id = id if id is not None else ''
 8757        '''
 8758         Unique identifier of the Resource.
 8759        '''
 8760        self.name = name if name is not None else ''
 8761        '''
 8762         Unique human-readable name of the Resource.
 8763        '''
 8764        self.password = password if password is not None else ''
 8765        self.port = port if port is not None else 0
 8766        self.port_override = port_override if port_override is not None else 0
 8767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8768        '''
 8769         ID of the secret store containing credentials for this resource, if any.
 8770        '''
 8771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8772        '''
 8773         Tags is a map of key, value pairs.
 8774        '''
 8775        self.tls_required = tls_required if tls_required is not None else False
 8776        self.username = username if username is not None else ''
 8777
 8778    def __repr__(self):
 8779        return '<sdm.RabbitMQAMQP091 ' + \
 8780            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8781            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8782            'healthy: ' + repr(self.healthy) + ' ' +\
 8783            'hostname: ' + repr(self.hostname) + ' ' +\
 8784            'id: ' + repr(self.id) + ' ' +\
 8785            'name: ' + repr(self.name) + ' ' +\
 8786            'password: ' + repr(self.password) + ' ' +\
 8787            'port: ' + repr(self.port) + ' ' +\
 8788            'port_override: ' + repr(self.port_override) + ' ' +\
 8789            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8790            'tags: ' + repr(self.tags) + ' ' +\
 8791            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8792            'username: ' + repr(self.username) + ' ' +\
 8793            '>'
 8794
 8795    def to_dict(self):
 8796        return {
 8797            'bind_interface': self.bind_interface,
 8798            'egress_filter': self.egress_filter,
 8799            'healthy': self.healthy,
 8800            'hostname': self.hostname,
 8801            'id': self.id,
 8802            'name': self.name,
 8803            'password': self.password,
 8804            'port': self.port,
 8805            'port_override': self.port_override,
 8806            'secret_store_id': self.secret_store_id,
 8807            'tags': self.tags,
 8808            'tls_required': self.tls_required,
 8809            'username': self.username,
 8810        }
 8811
 8812    @classmethod
 8813    def from_dict(cls, d):
 8814        return cls(
 8815            bind_interface=d.get('bind_interface'),
 8816            egress_filter=d.get('egress_filter'),
 8817            healthy=d.get('healthy'),
 8818            hostname=d.get('hostname'),
 8819            id=d.get('id'),
 8820            name=d.get('name'),
 8821            password=d.get('password'),
 8822            port=d.get('port'),
 8823            port_override=d.get('port_override'),
 8824            secret_store_id=d.get('secret_store_id'),
 8825            tags=d.get('tags'),
 8826            tls_required=d.get('tls_required'),
 8827            username=d.get('username'),
 8828        )
 8829
 8830
 8831class RateLimitMetadata:
 8832    '''
 8833         RateLimitMetadata contains information about remaining requests avaialable
 8834     to the user over some timeframe.
 8835    '''
 8836    __slots__ = [
 8837        'bucket',
 8838        'limit',
 8839        'remaining',
 8840        'reset_at',
 8841    ]
 8842
 8843    def __init__(
 8844        self,
 8845        bucket=None,
 8846        limit=None,
 8847        remaining=None,
 8848        reset_at=None,
 8849    ):
 8850        self.bucket = bucket if bucket is not None else ''
 8851        '''
 8852         The bucket this user/token is associated with, which may be shared between
 8853         multiple users/tokens.
 8854        '''
 8855        self.limit = limit if limit is not None else 0
 8856        '''
 8857         How many total requests the user/token is authorized to make before being
 8858         rate limited.
 8859        '''
 8860        self.remaining = remaining if remaining is not None else 0
 8861        '''
 8862         How many remaining requests out of the limit are still avaialable.
 8863        '''
 8864        self.reset_at = reset_at if reset_at is not None else None
 8865        '''
 8866         The time when remaining will be reset to limit.
 8867        '''
 8868
 8869    def __repr__(self):
 8870        return '<sdm.RateLimitMetadata ' + \
 8871            'bucket: ' + repr(self.bucket) + ' ' +\
 8872            'limit: ' + repr(self.limit) + ' ' +\
 8873            'remaining: ' + repr(self.remaining) + ' ' +\
 8874            'reset_at: ' + repr(self.reset_at) + ' ' +\
 8875            '>'
 8876
 8877    def to_dict(self):
 8878        return {
 8879            'bucket': self.bucket,
 8880            'limit': self.limit,
 8881            'remaining': self.remaining,
 8882            'reset_at': self.reset_at,
 8883        }
 8884
 8885    @classmethod
 8886    def from_dict(cls, d):
 8887        return cls(
 8888            bucket=d.get('bucket'),
 8889            limit=d.get('limit'),
 8890            remaining=d.get('remaining'),
 8891            reset_at=d.get('reset_at'),
 8892        )
 8893
 8894
 8895class RawTCP:
 8896    __slots__ = [
 8897        'bind_interface',
 8898        'egress_filter',
 8899        'healthy',
 8900        'hostname',
 8901        'id',
 8902        'name',
 8903        'port',
 8904        'port_override',
 8905        'secret_store_id',
 8906        'tags',
 8907    ]
 8908
 8909    def __init__(
 8910        self,
 8911        bind_interface=None,
 8912        egress_filter=None,
 8913        healthy=None,
 8914        hostname=None,
 8915        id=None,
 8916        name=None,
 8917        port=None,
 8918        port_override=None,
 8919        secret_store_id=None,
 8920        tags=None,
 8921    ):
 8922        self.bind_interface = bind_interface if bind_interface is not None else ''
 8923        '''
 8924         Bind interface
 8925        '''
 8926        self.egress_filter = egress_filter if egress_filter is not None else ''
 8927        '''
 8928         A filter applied to the routing logic to pin datasource to nodes.
 8929        '''
 8930        self.healthy = healthy if healthy is not None else False
 8931        '''
 8932         True if the datasource is reachable and the credentials are valid.
 8933        '''
 8934        self.hostname = hostname if hostname is not None else ''
 8935        self.id = id if id is not None else ''
 8936        '''
 8937         Unique identifier of the Resource.
 8938        '''
 8939        self.name = name if name is not None else ''
 8940        '''
 8941         Unique human-readable name of the Resource.
 8942        '''
 8943        self.port = port if port is not None else 0
 8944        self.port_override = port_override if port_override is not None else 0
 8945        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8946        '''
 8947         ID of the secret store containing credentials for this resource, if any.
 8948        '''
 8949        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8950        '''
 8951         Tags is a map of key, value pairs.
 8952        '''
 8953
 8954    def __repr__(self):
 8955        return '<sdm.RawTCP ' + \
 8956            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8957            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8958            'healthy: ' + repr(self.healthy) + ' ' +\
 8959            'hostname: ' + repr(self.hostname) + ' ' +\
 8960            'id: ' + repr(self.id) + ' ' +\
 8961            'name: ' + repr(self.name) + ' ' +\
 8962            'port: ' + repr(self.port) + ' ' +\
 8963            'port_override: ' + repr(self.port_override) + ' ' +\
 8964            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8965            'tags: ' + repr(self.tags) + ' ' +\
 8966            '>'
 8967
 8968    def to_dict(self):
 8969        return {
 8970            'bind_interface': self.bind_interface,
 8971            'egress_filter': self.egress_filter,
 8972            'healthy': self.healthy,
 8973            'hostname': self.hostname,
 8974            'id': self.id,
 8975            'name': self.name,
 8976            'port': self.port,
 8977            'port_override': self.port_override,
 8978            'secret_store_id': self.secret_store_id,
 8979            'tags': self.tags,
 8980        }
 8981
 8982    @classmethod
 8983    def from_dict(cls, d):
 8984        return cls(
 8985            bind_interface=d.get('bind_interface'),
 8986            egress_filter=d.get('egress_filter'),
 8987            healthy=d.get('healthy'),
 8988            hostname=d.get('hostname'),
 8989            id=d.get('id'),
 8990            name=d.get('name'),
 8991            port=d.get('port'),
 8992            port_override=d.get('port_override'),
 8993            secret_store_id=d.get('secret_store_id'),
 8994            tags=d.get('tags'),
 8995        )
 8996
 8997
 8998class Redis:
 8999    __slots__ = [
 9000        'bind_interface',
 9001        'egress_filter',
 9002        'healthy',
 9003        'hostname',
 9004        'id',
 9005        'name',
 9006        'password',
 9007        'port',
 9008        'port_override',
 9009        'secret_store_id',
 9010        'tags',
 9011    ]
 9012
 9013    def __init__(
 9014        self,
 9015        bind_interface=None,
 9016        egress_filter=None,
 9017        healthy=None,
 9018        hostname=None,
 9019        id=None,
 9020        name=None,
 9021        password=None,
 9022        port=None,
 9023        port_override=None,
 9024        secret_store_id=None,
 9025        tags=None,
 9026    ):
 9027        self.bind_interface = bind_interface if bind_interface is not None else ''
 9028        '''
 9029         Bind interface
 9030        '''
 9031        self.egress_filter = egress_filter if egress_filter is not None else ''
 9032        '''
 9033         A filter applied to the routing logic to pin datasource to nodes.
 9034        '''
 9035        self.healthy = healthy if healthy is not None else False
 9036        '''
 9037         True if the datasource is reachable and the credentials are valid.
 9038        '''
 9039        self.hostname = hostname if hostname is not None else ''
 9040        self.id = id if id is not None else ''
 9041        '''
 9042         Unique identifier of the Resource.
 9043        '''
 9044        self.name = name if name is not None else ''
 9045        '''
 9046         Unique human-readable name of the Resource.
 9047        '''
 9048        self.password = password if password is not None else ''
 9049        self.port = port if port is not None else 0
 9050        self.port_override = port_override if port_override is not None else 0
 9051        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9052        '''
 9053         ID of the secret store containing credentials for this resource, if any.
 9054        '''
 9055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9056        '''
 9057         Tags is a map of key, value pairs.
 9058        '''
 9059
 9060    def __repr__(self):
 9061        return '<sdm.Redis ' + \
 9062            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9063            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9064            'healthy: ' + repr(self.healthy) + ' ' +\
 9065            'hostname: ' + repr(self.hostname) + ' ' +\
 9066            'id: ' + repr(self.id) + ' ' +\
 9067            'name: ' + repr(self.name) + ' ' +\
 9068            'password: ' + repr(self.password) + ' ' +\
 9069            'port: ' + repr(self.port) + ' ' +\
 9070            'port_override: ' + repr(self.port_override) + ' ' +\
 9071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9072            'tags: ' + repr(self.tags) + ' ' +\
 9073            '>'
 9074
 9075    def to_dict(self):
 9076        return {
 9077            'bind_interface': self.bind_interface,
 9078            'egress_filter': self.egress_filter,
 9079            'healthy': self.healthy,
 9080            'hostname': self.hostname,
 9081            'id': self.id,
 9082            'name': self.name,
 9083            'password': self.password,
 9084            'port': self.port,
 9085            'port_override': self.port_override,
 9086            'secret_store_id': self.secret_store_id,
 9087            'tags': self.tags,
 9088        }
 9089
 9090    @classmethod
 9091    def from_dict(cls, d):
 9092        return cls(
 9093            bind_interface=d.get('bind_interface'),
 9094            egress_filter=d.get('egress_filter'),
 9095            healthy=d.get('healthy'),
 9096            hostname=d.get('hostname'),
 9097            id=d.get('id'),
 9098            name=d.get('name'),
 9099            password=d.get('password'),
 9100            port=d.get('port'),
 9101            port_override=d.get('port_override'),
 9102            secret_store_id=d.get('secret_store_id'),
 9103            tags=d.get('tags'),
 9104        )
 9105
 9106
 9107class Redshift:
 9108    __slots__ = [
 9109        'bind_interface',
 9110        'database',
 9111        'egress_filter',
 9112        'healthy',
 9113        'hostname',
 9114        'id',
 9115        'name',
 9116        'override_database',
 9117        'password',
 9118        'port',
 9119        'port_override',
 9120        'secret_store_id',
 9121        'tags',
 9122        'username',
 9123    ]
 9124
 9125    def __init__(
 9126        self,
 9127        bind_interface=None,
 9128        database=None,
 9129        egress_filter=None,
 9130        healthy=None,
 9131        hostname=None,
 9132        id=None,
 9133        name=None,
 9134        override_database=None,
 9135        password=None,
 9136        port=None,
 9137        port_override=None,
 9138        secret_store_id=None,
 9139        tags=None,
 9140        username=None,
 9141    ):
 9142        self.bind_interface = bind_interface if bind_interface is not None else ''
 9143        '''
 9144         Bind interface
 9145        '''
 9146        self.database = database if database is not None else ''
 9147        self.egress_filter = egress_filter if egress_filter is not None else ''
 9148        '''
 9149         A filter applied to the routing logic to pin datasource to nodes.
 9150        '''
 9151        self.healthy = healthy if healthy is not None else False
 9152        '''
 9153         True if the datasource is reachable and the credentials are valid.
 9154        '''
 9155        self.hostname = hostname if hostname is not None else ''
 9156        self.id = id if id is not None else ''
 9157        '''
 9158         Unique identifier of the Resource.
 9159        '''
 9160        self.name = name if name is not None else ''
 9161        '''
 9162         Unique human-readable name of the Resource.
 9163        '''
 9164        self.override_database = override_database if override_database is not None else False
 9165        self.password = password if password is not None else ''
 9166        self.port = port if port is not None else 0
 9167        self.port_override = port_override if port_override is not None else 0
 9168        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9169        '''
 9170         ID of the secret store containing credentials for this resource, if any.
 9171        '''
 9172        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9173        '''
 9174         Tags is a map of key, value pairs.
 9175        '''
 9176        self.username = username if username is not None else ''
 9177
 9178    def __repr__(self):
 9179        return '<sdm.Redshift ' + \
 9180            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9181            'database: ' + repr(self.database) + ' ' +\
 9182            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9183            'healthy: ' + repr(self.healthy) + ' ' +\
 9184            'hostname: ' + repr(self.hostname) + ' ' +\
 9185            'id: ' + repr(self.id) + ' ' +\
 9186            'name: ' + repr(self.name) + ' ' +\
 9187            'override_database: ' + repr(self.override_database) + ' ' +\
 9188            'password: ' + repr(self.password) + ' ' +\
 9189            'port: ' + repr(self.port) + ' ' +\
 9190            'port_override: ' + repr(self.port_override) + ' ' +\
 9191            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9192            'tags: ' + repr(self.tags) + ' ' +\
 9193            'username: ' + repr(self.username) + ' ' +\
 9194            '>'
 9195
 9196    def to_dict(self):
 9197        return {
 9198            'bind_interface': self.bind_interface,
 9199            'database': self.database,
 9200            'egress_filter': self.egress_filter,
 9201            'healthy': self.healthy,
 9202            'hostname': self.hostname,
 9203            'id': self.id,
 9204            'name': self.name,
 9205            'override_database': self.override_database,
 9206            'password': self.password,
 9207            'port': self.port,
 9208            'port_override': self.port_override,
 9209            'secret_store_id': self.secret_store_id,
 9210            'tags': self.tags,
 9211            'username': self.username,
 9212        }
 9213
 9214    @classmethod
 9215    def from_dict(cls, d):
 9216        return cls(
 9217            bind_interface=d.get('bind_interface'),
 9218            database=d.get('database'),
 9219            egress_filter=d.get('egress_filter'),
 9220            healthy=d.get('healthy'),
 9221            hostname=d.get('hostname'),
 9222            id=d.get('id'),
 9223            name=d.get('name'),
 9224            override_database=d.get('override_database'),
 9225            password=d.get('password'),
 9226            port=d.get('port'),
 9227            port_override=d.get('port_override'),
 9228            secret_store_id=d.get('secret_store_id'),
 9229            tags=d.get('tags'),
 9230            username=d.get('username'),
 9231        )
 9232
 9233
 9234class Relay:
 9235    '''
 9236         Relay represents a StrongDM CLI installation running in relay mode.
 9237    '''
 9238    __slots__ = [
 9239        'gateway_filter',
 9240        'id',
 9241        'name',
 9242        'state',
 9243        'tags',
 9244    ]
 9245
 9246    def __init__(
 9247        self,
 9248        gateway_filter=None,
 9249        id=None,
 9250        name=None,
 9251        state=None,
 9252        tags=None,
 9253    ):
 9254        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9255        '''
 9256         GatewayFilter can be used to restrict the peering between relays and
 9257         gateways.
 9258        '''
 9259        self.id = id if id is not None else ''
 9260        '''
 9261         Unique identifier of the Relay.
 9262        '''
 9263        self.name = name if name is not None else ''
 9264        '''
 9265         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9266        '''
 9267        self.state = state if state is not None else ''
 9268        '''
 9269         The current state of the relay. One of: "new", "verifying_restart",
 9270         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9271         "unknown".
 9272        '''
 9273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9274        '''
 9275         Tags is a map of key, value pairs.
 9276        '''
 9277
 9278    def __repr__(self):
 9279        return '<sdm.Relay ' + \
 9280            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9281            'id: ' + repr(self.id) + ' ' +\
 9282            'name: ' + repr(self.name) + ' ' +\
 9283            'state: ' + repr(self.state) + ' ' +\
 9284            'tags: ' + repr(self.tags) + ' ' +\
 9285            '>'
 9286
 9287    def to_dict(self):
 9288        return {
 9289            'gateway_filter': self.gateway_filter,
 9290            'id': self.id,
 9291            'name': self.name,
 9292            'state': self.state,
 9293            'tags': self.tags,
 9294        }
 9295
 9296    @classmethod
 9297    def from_dict(cls, d):
 9298        return cls(
 9299            gateway_filter=d.get('gateway_filter'),
 9300            id=d.get('id'),
 9301            name=d.get('name'),
 9302            state=d.get('state'),
 9303            tags=d.get('tags'),
 9304        )
 9305
 9306
 9307class RemoteIdentity:
 9308    '''
 9309         RemoteIdentities define the username to be used for a specific account
 9310     when connecting to a remote resource using that group.
 9311    '''
 9312    __slots__ = [
 9313        'account_id',
 9314        'id',
 9315        'remote_identity_group_id',
 9316        'username',
 9317    ]
 9318
 9319    def __init__(
 9320        self,
 9321        account_id=None,
 9322        id=None,
 9323        remote_identity_group_id=None,
 9324        username=None,
 9325    ):
 9326        self.account_id = account_id if account_id is not None else ''
 9327        '''
 9328         The account for this remote identity.
 9329        '''
 9330        self.id = id if id is not None else ''
 9331        '''
 9332         Unique identifier of the RemoteIdentity.
 9333        '''
 9334        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9335        '''
 9336         The remote identity group.
 9337        '''
 9338        self.username = username if username is not None else ''
 9339        '''
 9340         The username to be used as the remote identity for this account.
 9341        '''
 9342
 9343    def __repr__(self):
 9344        return '<sdm.RemoteIdentity ' + \
 9345            'account_id: ' + repr(self.account_id) + ' ' +\
 9346            'id: ' + repr(self.id) + ' ' +\
 9347            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9348            'username: ' + repr(self.username) + ' ' +\
 9349            '>'
 9350
 9351    def to_dict(self):
 9352        return {
 9353            'account_id': self.account_id,
 9354            'id': self.id,
 9355            'remote_identity_group_id': self.remote_identity_group_id,
 9356            'username': self.username,
 9357        }
 9358
 9359    @classmethod
 9360    def from_dict(cls, d):
 9361        return cls(
 9362            account_id=d.get('account_id'),
 9363            id=d.get('id'),
 9364            remote_identity_group_id=d.get('remote_identity_group_id'),
 9365            username=d.get('username'),
 9366        )
 9367
 9368
 9369class RemoteIdentityCreateResponse:
 9370    '''
 9371         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9372    '''
 9373    __slots__ = [
 9374        'meta',
 9375        'rate_limit',
 9376        'remote_identity',
 9377    ]
 9378
 9379    def __init__(
 9380        self,
 9381        meta=None,
 9382        rate_limit=None,
 9383        remote_identity=None,
 9384    ):
 9385        self.meta = meta if meta is not None else None
 9386        '''
 9387         Reserved for future use.
 9388        '''
 9389        self.rate_limit = rate_limit if rate_limit is not None else None
 9390        '''
 9391         Rate limit information.
 9392        '''
 9393        self.remote_identity = remote_identity if remote_identity is not None else None
 9394        '''
 9395         The created RemoteIdentity.
 9396        '''
 9397
 9398    def __repr__(self):
 9399        return '<sdm.RemoteIdentityCreateResponse ' + \
 9400            'meta: ' + repr(self.meta) + ' ' +\
 9401            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9402            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9403            '>'
 9404
 9405    def to_dict(self):
 9406        return {
 9407            'meta': self.meta,
 9408            'rate_limit': self.rate_limit,
 9409            'remote_identity': self.remote_identity,
 9410        }
 9411
 9412    @classmethod
 9413    def from_dict(cls, d):
 9414        return cls(
 9415            meta=d.get('meta'),
 9416            rate_limit=d.get('rate_limit'),
 9417            remote_identity=d.get('remote_identity'),
 9418        )
 9419
 9420
 9421class RemoteIdentityDeleteResponse:
 9422    '''
 9423         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9424    '''
 9425    __slots__ = [
 9426        'meta',
 9427        'rate_limit',
 9428    ]
 9429
 9430    def __init__(
 9431        self,
 9432        meta=None,
 9433        rate_limit=None,
 9434    ):
 9435        self.meta = meta if meta is not None else None
 9436        '''
 9437         Reserved for future use.
 9438        '''
 9439        self.rate_limit = rate_limit if rate_limit is not None else None
 9440        '''
 9441         Rate limit information.
 9442        '''
 9443
 9444    def __repr__(self):
 9445        return '<sdm.RemoteIdentityDeleteResponse ' + \
 9446            'meta: ' + repr(self.meta) + ' ' +\
 9447            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9448            '>'
 9449
 9450    def to_dict(self):
 9451        return {
 9452            'meta': self.meta,
 9453            'rate_limit': self.rate_limit,
 9454        }
 9455
 9456    @classmethod
 9457    def from_dict(cls, d):
 9458        return cls(
 9459            meta=d.get('meta'),
 9460            rate_limit=d.get('rate_limit'),
 9461        )
 9462
 9463
 9464class RemoteIdentityGetResponse:
 9465    '''
 9466         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9467    '''
 9468    __slots__ = [
 9469        'meta',
 9470        'rate_limit',
 9471        'remote_identity',
 9472    ]
 9473
 9474    def __init__(
 9475        self,
 9476        meta=None,
 9477        rate_limit=None,
 9478        remote_identity=None,
 9479    ):
 9480        self.meta = meta if meta is not None else None
 9481        '''
 9482         Reserved for future use.
 9483        '''
 9484        self.rate_limit = rate_limit if rate_limit is not None else None
 9485        '''
 9486         Rate limit information.
 9487        '''
 9488        self.remote_identity = remote_identity if remote_identity is not None else None
 9489        '''
 9490         The requested RemoteIdentity.
 9491        '''
 9492
 9493    def __repr__(self):
 9494        return '<sdm.RemoteIdentityGetResponse ' + \
 9495            'meta: ' + repr(self.meta) + ' ' +\
 9496            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9497            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9498            '>'
 9499
 9500    def to_dict(self):
 9501        return {
 9502            'meta': self.meta,
 9503            'rate_limit': self.rate_limit,
 9504            'remote_identity': self.remote_identity,
 9505        }
 9506
 9507    @classmethod
 9508    def from_dict(cls, d):
 9509        return cls(
 9510            meta=d.get('meta'),
 9511            rate_limit=d.get('rate_limit'),
 9512            remote_identity=d.get('remote_identity'),
 9513        )
 9514
 9515
 9516class RemoteIdentityGroup:
 9517    '''
 9518         A RemoteIdentityGroup defines a group of remote identities.
 9519    '''
 9520    __slots__ = [
 9521        'id',
 9522        'name',
 9523    ]
 9524
 9525    def __init__(
 9526        self,
 9527        id=None,
 9528        name=None,
 9529    ):
 9530        self.id = id if id is not None else ''
 9531        '''
 9532         Unique identifier of the RemoteIdentityGroup.
 9533        '''
 9534        self.name = name if name is not None else ''
 9535        '''
 9536         Unique human-readable name of the RemoteIdentityGroup.
 9537        '''
 9538
 9539    def __repr__(self):
 9540        return '<sdm.RemoteIdentityGroup ' + \
 9541            'id: ' + repr(self.id) + ' ' +\
 9542            'name: ' + repr(self.name) + ' ' +\
 9543            '>'
 9544
 9545    def to_dict(self):
 9546        return {
 9547            'id': self.id,
 9548            'name': self.name,
 9549        }
 9550
 9551    @classmethod
 9552    def from_dict(cls, d):
 9553        return cls(
 9554            id=d.get('id'),
 9555            name=d.get('name'),
 9556        )
 9557
 9558
 9559class RemoteIdentityGroupGetResponse:
 9560    '''
 9561         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
 9562    '''
 9563    __slots__ = [
 9564        'meta',
 9565        'rate_limit',
 9566        'remote_identity_group',
 9567    ]
 9568
 9569    def __init__(
 9570        self,
 9571        meta=None,
 9572        rate_limit=None,
 9573        remote_identity_group=None,
 9574    ):
 9575        self.meta = meta if meta is not None else None
 9576        '''
 9577         Reserved for future use.
 9578        '''
 9579        self.rate_limit = rate_limit if rate_limit is not None else None
 9580        '''
 9581         Rate limit information.
 9582        '''
 9583        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
 9584        '''
 9585         The requested RemoteIdentityGroup.
 9586        '''
 9587
 9588    def __repr__(self):
 9589        return '<sdm.RemoteIdentityGroupGetResponse ' + \
 9590            'meta: ' + repr(self.meta) + ' ' +\
 9591            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9592            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
 9593            '>'
 9594
 9595    def to_dict(self):
 9596        return {
 9597            'meta': self.meta,
 9598            'rate_limit': self.rate_limit,
 9599            'remote_identity_group': self.remote_identity_group,
 9600        }
 9601
 9602    @classmethod
 9603    def from_dict(cls, d):
 9604        return cls(
 9605            meta=d.get('meta'),
 9606            rate_limit=d.get('rate_limit'),
 9607            remote_identity_group=d.get('remote_identity_group'),
 9608        )
 9609
 9610
 9611class RemoteIdentityUpdateResponse:
 9612    '''
 9613         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
 9614     a RemoteIdentityUpdateRequest.
 9615    '''
 9616    __slots__ = [
 9617        'meta',
 9618        'rate_limit',
 9619        'remote_identity',
 9620    ]
 9621
 9622    def __init__(
 9623        self,
 9624        meta=None,
 9625        rate_limit=None,
 9626        remote_identity=None,
 9627    ):
 9628        self.meta = meta if meta is not None else None
 9629        '''
 9630         Reserved for future use.
 9631        '''
 9632        self.rate_limit = rate_limit if rate_limit is not None else None
 9633        '''
 9634         Rate limit information.
 9635        '''
 9636        self.remote_identity = remote_identity if remote_identity is not None else None
 9637        '''
 9638         The updated RemoteIdentity.
 9639        '''
 9640
 9641    def __repr__(self):
 9642        return '<sdm.RemoteIdentityUpdateResponse ' + \
 9643            'meta: ' + repr(self.meta) + ' ' +\
 9644            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9645            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9646            '>'
 9647
 9648    def to_dict(self):
 9649        return {
 9650            'meta': self.meta,
 9651            'rate_limit': self.rate_limit,
 9652            'remote_identity': self.remote_identity,
 9653        }
 9654
 9655    @classmethod
 9656    def from_dict(cls, d):
 9657        return cls(
 9658            meta=d.get('meta'),
 9659            rate_limit=d.get('rate_limit'),
 9660            remote_identity=d.get('remote_identity'),
 9661        )
 9662
 9663
 9664class ResourceCreateResponse:
 9665    '''
 9666         ResourceCreateResponse reports how the Resources were created in the system.
 9667    '''
 9668    __slots__ = [
 9669        'meta',
 9670        'rate_limit',
 9671        'resource',
 9672    ]
 9673
 9674    def __init__(
 9675        self,
 9676        meta=None,
 9677        rate_limit=None,
 9678        resource=None,
 9679    ):
 9680        self.meta = meta if meta is not None else None
 9681        '''
 9682         Reserved for future use.
 9683        '''
 9684        self.rate_limit = rate_limit if rate_limit is not None else None
 9685        '''
 9686         Rate limit information.
 9687        '''
 9688        self.resource = resource if resource is not None else None
 9689        '''
 9690         The created Resource.
 9691        '''
 9692
 9693    def __repr__(self):
 9694        return '<sdm.ResourceCreateResponse ' + \
 9695            'meta: ' + repr(self.meta) + ' ' +\
 9696            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9697            'resource: ' + repr(self.resource) + ' ' +\
 9698            '>'
 9699
 9700    def to_dict(self):
 9701        return {
 9702            'meta': self.meta,
 9703            'rate_limit': self.rate_limit,
 9704            'resource': self.resource,
 9705        }
 9706
 9707    @classmethod
 9708    def from_dict(cls, d):
 9709        return cls(
 9710            meta=d.get('meta'),
 9711            rate_limit=d.get('rate_limit'),
 9712            resource=d.get('resource'),
 9713        )
 9714
 9715
 9716class ResourceDeleteResponse:
 9717    '''
 9718         ResourceDeleteResponse returns information about a Resource that was deleted.
 9719    '''
 9720    __slots__ = [
 9721        'meta',
 9722        'rate_limit',
 9723    ]
 9724
 9725    def __init__(
 9726        self,
 9727        meta=None,
 9728        rate_limit=None,
 9729    ):
 9730        self.meta = meta if meta is not None else None
 9731        '''
 9732         Reserved for future use.
 9733        '''
 9734        self.rate_limit = rate_limit if rate_limit is not None else None
 9735        '''
 9736         Rate limit information.
 9737        '''
 9738
 9739    def __repr__(self):
 9740        return '<sdm.ResourceDeleteResponse ' + \
 9741            'meta: ' + repr(self.meta) + ' ' +\
 9742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9743            '>'
 9744
 9745    def to_dict(self):
 9746        return {
 9747            'meta': self.meta,
 9748            'rate_limit': self.rate_limit,
 9749        }
 9750
 9751    @classmethod
 9752    def from_dict(cls, d):
 9753        return cls(
 9754            meta=d.get('meta'),
 9755            rate_limit=d.get('rate_limit'),
 9756        )
 9757
 9758
 9759class ResourceGetResponse:
 9760    '''
 9761         ResourceGetResponse returns a requested Resource.
 9762    '''
 9763    __slots__ = [
 9764        'meta',
 9765        'rate_limit',
 9766        'resource',
 9767    ]
 9768
 9769    def __init__(
 9770        self,
 9771        meta=None,
 9772        rate_limit=None,
 9773        resource=None,
 9774    ):
 9775        self.meta = meta if meta is not None else None
 9776        '''
 9777         Reserved for future use.
 9778        '''
 9779        self.rate_limit = rate_limit if rate_limit is not None else None
 9780        '''
 9781         Rate limit information.
 9782        '''
 9783        self.resource = resource if resource is not None else None
 9784        '''
 9785         The requested Resource.
 9786        '''
 9787
 9788    def __repr__(self):
 9789        return '<sdm.ResourceGetResponse ' + \
 9790            'meta: ' + repr(self.meta) + ' ' +\
 9791            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9792            'resource: ' + repr(self.resource) + ' ' +\
 9793            '>'
 9794
 9795    def to_dict(self):
 9796        return {
 9797            'meta': self.meta,
 9798            'rate_limit': self.rate_limit,
 9799            'resource': self.resource,
 9800        }
 9801
 9802    @classmethod
 9803    def from_dict(cls, d):
 9804        return cls(
 9805            meta=d.get('meta'),
 9806            rate_limit=d.get('rate_limit'),
 9807            resource=d.get('resource'),
 9808        )
 9809
 9810
 9811class ResourceUpdateResponse:
 9812    '''
 9813         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
 9814     a ResourceUpdateRequest.
 9815    '''
 9816    __slots__ = [
 9817        'meta',
 9818        'rate_limit',
 9819        'resource',
 9820    ]
 9821
 9822    def __init__(
 9823        self,
 9824        meta=None,
 9825        rate_limit=None,
 9826        resource=None,
 9827    ):
 9828        self.meta = meta if meta is not None else None
 9829        '''
 9830         Reserved for future use.
 9831        '''
 9832        self.rate_limit = rate_limit if rate_limit is not None else None
 9833        '''
 9834         Rate limit information.
 9835        '''
 9836        self.resource = resource if resource is not None else None
 9837        '''
 9838         The updated Resource.
 9839        '''
 9840
 9841    def __repr__(self):
 9842        return '<sdm.ResourceUpdateResponse ' + \
 9843            'meta: ' + repr(self.meta) + ' ' +\
 9844            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9845            'resource: ' + repr(self.resource) + ' ' +\
 9846            '>'
 9847
 9848    def to_dict(self):
 9849        return {
 9850            'meta': self.meta,
 9851            'rate_limit': self.rate_limit,
 9852            'resource': self.resource,
 9853        }
 9854
 9855    @classmethod
 9856    def from_dict(cls, d):
 9857        return cls(
 9858            meta=d.get('meta'),
 9859            rate_limit=d.get('rate_limit'),
 9860            resource=d.get('resource'),
 9861        )
 9862
 9863
 9864class Role:
 9865    '''
 9866         A Role has a list of access rules which determine which Resources the members
 9867     of the Role have access to. An Account can be a member of multiple Roles via
 9868     AccountAttachments.
 9869    '''
 9870    __slots__ = [
 9871        'access_rules',
 9872        'id',
 9873        'name',
 9874        'tags',
 9875    ]
 9876
 9877    def __init__(
 9878        self,
 9879        access_rules=None,
 9880        id=None,
 9881        name=None,
 9882        tags=None,
 9883    ):
 9884        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
 9885        )
 9886        '''
 9887         AccessRules is a list of access rules defining the resources this Role has access to.
 9888        '''
 9889        self.id = id if id is not None else ''
 9890        '''
 9891         Unique identifier of the Role.
 9892        '''
 9893        self.name = name if name is not None else ''
 9894        '''
 9895         Unique human-readable name of the Role.
 9896        '''
 9897        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9898        '''
 9899         Tags is a map of key, value pairs.
 9900        '''
 9901
 9902    def __repr__(self):
 9903        return '<sdm.Role ' + \
 9904            'access_rules: ' + repr(self.access_rules) + ' ' +\
 9905            'id: ' + repr(self.id) + ' ' +\
 9906            'name: ' + repr(self.name) + ' ' +\
 9907            'tags: ' + repr(self.tags) + ' ' +\
 9908            '>'
 9909
 9910    def to_dict(self):
 9911        return {
 9912            'access_rules': self.access_rules,
 9913            'id': self.id,
 9914            'name': self.name,
 9915            'tags': self.tags,
 9916        }
 9917
 9918    @classmethod
 9919    def from_dict(cls, d):
 9920        return cls(
 9921            access_rules=d.get('access_rules'),
 9922            id=d.get('id'),
 9923            name=d.get('name'),
 9924            tags=d.get('tags'),
 9925        )
 9926
 9927
 9928class RoleCreateResponse:
 9929    '''
 9930         RoleCreateResponse reports how the Roles were created in the system. It can
 9931     communicate partial successes or failures.
 9932    '''
 9933    __slots__ = [
 9934        'meta',
 9935        'rate_limit',
 9936        'role',
 9937    ]
 9938
 9939    def __init__(
 9940        self,
 9941        meta=None,
 9942        rate_limit=None,
 9943        role=None,
 9944    ):
 9945        self.meta = meta if meta is not None else None
 9946        '''
 9947         Reserved for future use.
 9948        '''
 9949        self.rate_limit = rate_limit if rate_limit is not None else None
 9950        '''
 9951         Rate limit information.
 9952        '''
 9953        self.role = role if role is not None else None
 9954        '''
 9955         The created Role.
 9956        '''
 9957
 9958    def __repr__(self):
 9959        return '<sdm.RoleCreateResponse ' + \
 9960            'meta: ' + repr(self.meta) + ' ' +\
 9961            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9962            'role: ' + repr(self.role) + ' ' +\
 9963            '>'
 9964
 9965    def to_dict(self):
 9966        return {
 9967            'meta': self.meta,
 9968            'rate_limit': self.rate_limit,
 9969            'role': self.role,
 9970        }
 9971
 9972    @classmethod
 9973    def from_dict(cls, d):
 9974        return cls(
 9975            meta=d.get('meta'),
 9976            rate_limit=d.get('rate_limit'),
 9977            role=d.get('role'),
 9978        )
 9979
 9980
 9981class RoleDeleteResponse:
 9982    '''
 9983         RoleDeleteResponse returns information about a Role that was deleted.
 9984    '''
 9985    __slots__ = [
 9986        'meta',
 9987        'rate_limit',
 9988    ]
 9989
 9990    def __init__(
 9991        self,
 9992        meta=None,
 9993        rate_limit=None,
 9994    ):
 9995        self.meta = meta if meta is not None else None
 9996        '''
 9997         Reserved for future use.
 9998        '''
 9999        self.rate_limit = rate_limit if rate_limit is not None else None
10000        '''
10001         Rate limit information.
10002        '''
10003
10004    def __repr__(self):
10005        return '<sdm.RoleDeleteResponse ' + \
10006            'meta: ' + repr(self.meta) + ' ' +\
10007            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10008            '>'
10009
10010    def to_dict(self):
10011        return {
10012            'meta': self.meta,
10013            'rate_limit': self.rate_limit,
10014        }
10015
10016    @classmethod
10017    def from_dict(cls, d):
10018        return cls(
10019            meta=d.get('meta'),
10020            rate_limit=d.get('rate_limit'),
10021        )
10022
10023
10024class RoleGetResponse:
10025    '''
10026         RoleGetResponse returns a requested Role.
10027    '''
10028    __slots__ = [
10029        'meta',
10030        'rate_limit',
10031        'role',
10032    ]
10033
10034    def __init__(
10035        self,
10036        meta=None,
10037        rate_limit=None,
10038        role=None,
10039    ):
10040        self.meta = meta if meta is not None else None
10041        '''
10042         Reserved for future use.
10043        '''
10044        self.rate_limit = rate_limit if rate_limit is not None else None
10045        '''
10046         Rate limit information.
10047        '''
10048        self.role = role if role is not None else None
10049        '''
10050         The requested Role.
10051        '''
10052
10053    def __repr__(self):
10054        return '<sdm.RoleGetResponse ' + \
10055            'meta: ' + repr(self.meta) + ' ' +\
10056            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10057            'role: ' + repr(self.role) + ' ' +\
10058            '>'
10059
10060    def to_dict(self):
10061        return {
10062            'meta': self.meta,
10063            'rate_limit': self.rate_limit,
10064            'role': self.role,
10065        }
10066
10067    @classmethod
10068    def from_dict(cls, d):
10069        return cls(
10070            meta=d.get('meta'),
10071            rate_limit=d.get('rate_limit'),
10072            role=d.get('role'),
10073        )
10074
10075
10076class RoleUpdateResponse:
10077    '''
10078         RoleUpdateResponse returns the fields of a Role after it has been updated by
10079     a RoleUpdateRequest.
10080    '''
10081    __slots__ = [
10082        'meta',
10083        'rate_limit',
10084        'role',
10085    ]
10086
10087    def __init__(
10088        self,
10089        meta=None,
10090        rate_limit=None,
10091        role=None,
10092    ):
10093        self.meta = meta if meta is not None else None
10094        '''
10095         Reserved for future use.
10096        '''
10097        self.rate_limit = rate_limit if rate_limit is not None else None
10098        '''
10099         Rate limit information.
10100        '''
10101        self.role = role if role is not None else None
10102        '''
10103         The updated Role.
10104        '''
10105
10106    def __repr__(self):
10107        return '<sdm.RoleUpdateResponse ' + \
10108            'meta: ' + repr(self.meta) + ' ' +\
10109            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10110            'role: ' + repr(self.role) + ' ' +\
10111            '>'
10112
10113    def to_dict(self):
10114        return {
10115            'meta': self.meta,
10116            'rate_limit': self.rate_limit,
10117            'role': self.role,
10118        }
10119
10120    @classmethod
10121    def from_dict(cls, d):
10122        return cls(
10123            meta=d.get('meta'),
10124            rate_limit=d.get('rate_limit'),
10125            role=d.get('role'),
10126        )
10127
10128
10129class SQLServer:
10130    __slots__ = [
10131        'bind_interface',
10132        'database',
10133        'egress_filter',
10134        'healthy',
10135        'hostname',
10136        'id',
10137        'name',
10138        'override_database',
10139        'password',
10140        'port',
10141        'port_override',
10142        'schema',
10143        'secret_store_id',
10144        'tags',
10145        'username',
10146    ]
10147
10148    def __init__(
10149        self,
10150        bind_interface=None,
10151        database=None,
10152        egress_filter=None,
10153        healthy=None,
10154        hostname=None,
10155        id=None,
10156        name=None,
10157        override_database=None,
10158        password=None,
10159        port=None,
10160        port_override=None,
10161        schema=None,
10162        secret_store_id=None,
10163        tags=None,
10164        username=None,
10165    ):
10166        self.bind_interface = bind_interface if bind_interface is not None else ''
10167        '''
10168         Bind interface
10169        '''
10170        self.database = database if database is not None else ''
10171        self.egress_filter = egress_filter if egress_filter is not None else ''
10172        '''
10173         A filter applied to the routing logic to pin datasource to nodes.
10174        '''
10175        self.healthy = healthy if healthy is not None else False
10176        '''
10177         True if the datasource is reachable and the credentials are valid.
10178        '''
10179        self.hostname = hostname if hostname is not None else ''
10180        self.id = id if id is not None else ''
10181        '''
10182         Unique identifier of the Resource.
10183        '''
10184        self.name = name if name is not None else ''
10185        '''
10186         Unique human-readable name of the Resource.
10187        '''
10188        self.override_database = override_database if override_database is not None else False
10189        self.password = password if password is not None else ''
10190        self.port = port if port is not None else 0
10191        self.port_override = port_override if port_override is not None else 0
10192        self.schema = schema if schema is not None else ''
10193        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10194        '''
10195         ID of the secret store containing credentials for this resource, if any.
10196        '''
10197        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10198        '''
10199         Tags is a map of key, value pairs.
10200        '''
10201        self.username = username if username is not None else ''
10202
10203    def __repr__(self):
10204        return '<sdm.SQLServer ' + \
10205            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10206            'database: ' + repr(self.database) + ' ' +\
10207            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10208            'healthy: ' + repr(self.healthy) + ' ' +\
10209            'hostname: ' + repr(self.hostname) + ' ' +\
10210            'id: ' + repr(self.id) + ' ' +\
10211            'name: ' + repr(self.name) + ' ' +\
10212            'override_database: ' + repr(self.override_database) + ' ' +\
10213            'password: ' + repr(self.password) + ' ' +\
10214            'port: ' + repr(self.port) + ' ' +\
10215            'port_override: ' + repr(self.port_override) + ' ' +\
10216            'schema: ' + repr(self.schema) + ' ' +\
10217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10218            'tags: ' + repr(self.tags) + ' ' +\
10219            'username: ' + repr(self.username) + ' ' +\
10220            '>'
10221
10222    def to_dict(self):
10223        return {
10224            'bind_interface': self.bind_interface,
10225            'database': self.database,
10226            'egress_filter': self.egress_filter,
10227            'healthy': self.healthy,
10228            'hostname': self.hostname,
10229            'id': self.id,
10230            'name': self.name,
10231            'override_database': self.override_database,
10232            'password': self.password,
10233            'port': self.port,
10234            'port_override': self.port_override,
10235            'schema': self.schema,
10236            'secret_store_id': self.secret_store_id,
10237            'tags': self.tags,
10238            'username': self.username,
10239        }
10240
10241    @classmethod
10242    def from_dict(cls, d):
10243        return cls(
10244            bind_interface=d.get('bind_interface'),
10245            database=d.get('database'),
10246            egress_filter=d.get('egress_filter'),
10247            healthy=d.get('healthy'),
10248            hostname=d.get('hostname'),
10249            id=d.get('id'),
10250            name=d.get('name'),
10251            override_database=d.get('override_database'),
10252            password=d.get('password'),
10253            port=d.get('port'),
10254            port_override=d.get('port_override'),
10255            schema=d.get('schema'),
10256            secret_store_id=d.get('secret_store_id'),
10257            tags=d.get('tags'),
10258            username=d.get('username'),
10259        )
10260
10261
10262class SSH:
10263    __slots__ = [
10264        'allow_deprecated_key_exchanges',
10265        'bind_interface',
10266        'egress_filter',
10267        'healthy',
10268        'hostname',
10269        'id',
10270        'key_type',
10271        'name',
10272        'port',
10273        'port_forwarding',
10274        'port_override',
10275        'public_key',
10276        'secret_store_id',
10277        'tags',
10278        'username',
10279    ]
10280
10281    def __init__(
10282        self,
10283        allow_deprecated_key_exchanges=None,
10284        bind_interface=None,
10285        egress_filter=None,
10286        healthy=None,
10287        hostname=None,
10288        id=None,
10289        key_type=None,
10290        name=None,
10291        port=None,
10292        port_forwarding=None,
10293        port_override=None,
10294        public_key=None,
10295        secret_store_id=None,
10296        tags=None,
10297        username=None,
10298    ):
10299        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10300        self.bind_interface = bind_interface if bind_interface is not None else ''
10301        '''
10302         Bind interface
10303        '''
10304        self.egress_filter = egress_filter if egress_filter is not None else ''
10305        '''
10306         A filter applied to the routing logic to pin datasource to nodes.
10307        '''
10308        self.healthy = healthy if healthy is not None else False
10309        '''
10310         True if the datasource is reachable and the credentials are valid.
10311        '''
10312        self.hostname = hostname if hostname is not None else ''
10313        self.id = id if id is not None else ''
10314        '''
10315         Unique identifier of the Resource.
10316        '''
10317        self.key_type = key_type if key_type is not None else ''
10318        self.name = name if name is not None else ''
10319        '''
10320         Unique human-readable name of the Resource.
10321        '''
10322        self.port = port if port is not None else 0
10323        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10324        self.port_override = port_override if port_override is not None else 0
10325        self.public_key = public_key if public_key is not None else ''
10326        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10327        '''
10328         ID of the secret store containing credentials for this resource, if any.
10329        '''
10330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10331        '''
10332         Tags is a map of key, value pairs.
10333        '''
10334        self.username = username if username is not None else ''
10335
10336    def __repr__(self):
10337        return '<sdm.SSH ' + \
10338            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10339            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10340            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10341            'healthy: ' + repr(self.healthy) + ' ' +\
10342            'hostname: ' + repr(self.hostname) + ' ' +\
10343            'id: ' + repr(self.id) + ' ' +\
10344            'key_type: ' + repr(self.key_type) + ' ' +\
10345            'name: ' + repr(self.name) + ' ' +\
10346            'port: ' + repr(self.port) + ' ' +\
10347            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10348            'port_override: ' + repr(self.port_override) + ' ' +\
10349            'public_key: ' + repr(self.public_key) + ' ' +\
10350            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10351            'tags: ' + repr(self.tags) + ' ' +\
10352            'username: ' + repr(self.username) + ' ' +\
10353            '>'
10354
10355    def to_dict(self):
10356        return {
10357            'allow_deprecated_key_exchanges':
10358            self.allow_deprecated_key_exchanges,
10359            'bind_interface': self.bind_interface,
10360            'egress_filter': self.egress_filter,
10361            'healthy': self.healthy,
10362            'hostname': self.hostname,
10363            'id': self.id,
10364            'key_type': self.key_type,
10365            'name': self.name,
10366            'port': self.port,
10367            'port_forwarding': self.port_forwarding,
10368            'port_override': self.port_override,
10369            'public_key': self.public_key,
10370            'secret_store_id': self.secret_store_id,
10371            'tags': self.tags,
10372            'username': self.username,
10373        }
10374
10375    @classmethod
10376    def from_dict(cls, d):
10377        return cls(
10378            allow_deprecated_key_exchanges=d.get(
10379                'allow_deprecated_key_exchanges'),
10380            bind_interface=d.get('bind_interface'),
10381            egress_filter=d.get('egress_filter'),
10382            healthy=d.get('healthy'),
10383            hostname=d.get('hostname'),
10384            id=d.get('id'),
10385            key_type=d.get('key_type'),
10386            name=d.get('name'),
10387            port=d.get('port'),
10388            port_forwarding=d.get('port_forwarding'),
10389            port_override=d.get('port_override'),
10390            public_key=d.get('public_key'),
10391            secret_store_id=d.get('secret_store_id'),
10392            tags=d.get('tags'),
10393            username=d.get('username'),
10394        )
10395
10396
10397class SSHCert:
10398    __slots__ = [
10399        'allow_deprecated_key_exchanges',
10400        'bind_interface',
10401        'egress_filter',
10402        'healthy',
10403        'hostname',
10404        'id',
10405        'key_type',
10406        'name',
10407        'port',
10408        'port_forwarding',
10409        'port_override',
10410        'remote_identity_group_id',
10411        'remote_identity_healthcheck_username',
10412        'secret_store_id',
10413        'tags',
10414        'username',
10415    ]
10416
10417    def __init__(
10418        self,
10419        allow_deprecated_key_exchanges=None,
10420        bind_interface=None,
10421        egress_filter=None,
10422        healthy=None,
10423        hostname=None,
10424        id=None,
10425        key_type=None,
10426        name=None,
10427        port=None,
10428        port_forwarding=None,
10429        port_override=None,
10430        remote_identity_group_id=None,
10431        remote_identity_healthcheck_username=None,
10432        secret_store_id=None,
10433        tags=None,
10434        username=None,
10435    ):
10436        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10437        self.bind_interface = bind_interface if bind_interface is not None else ''
10438        '''
10439         Bind interface
10440        '''
10441        self.egress_filter = egress_filter if egress_filter is not None else ''
10442        '''
10443         A filter applied to the routing logic to pin datasource to nodes.
10444        '''
10445        self.healthy = healthy if healthy is not None else False
10446        '''
10447         True if the datasource is reachable and the credentials are valid.
10448        '''
10449        self.hostname = hostname if hostname is not None else ''
10450        self.id = id if id is not None else ''
10451        '''
10452         Unique identifier of the Resource.
10453        '''
10454        self.key_type = key_type if key_type is not None else ''
10455        self.name = name if name is not None else ''
10456        '''
10457         Unique human-readable name of the Resource.
10458        '''
10459        self.port = port if port is not None else 0
10460        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10461        self.port_override = port_override if port_override is not None else 0
10462        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10463        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10464        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10465        '''
10466         ID of the secret store containing credentials for this resource, if any.
10467        '''
10468        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10469        '''
10470         Tags is a map of key, value pairs.
10471        '''
10472        self.username = username if username is not None else ''
10473
10474    def __repr__(self):
10475        return '<sdm.SSHCert ' + \
10476            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10477            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10478            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10479            'healthy: ' + repr(self.healthy) + ' ' +\
10480            'hostname: ' + repr(self.hostname) + ' ' +\
10481            'id: ' + repr(self.id) + ' ' +\
10482            'key_type: ' + repr(self.key_type) + ' ' +\
10483            'name: ' + repr(self.name) + ' ' +\
10484            'port: ' + repr(self.port) + ' ' +\
10485            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10486            'port_override: ' + repr(self.port_override) + ' ' +\
10487            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10488            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10489            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10490            'tags: ' + repr(self.tags) + ' ' +\
10491            'username: ' + repr(self.username) + ' ' +\
10492            '>'
10493
10494    def to_dict(self):
10495        return {
10496            'allow_deprecated_key_exchanges':
10497            self.allow_deprecated_key_exchanges,
10498            'bind_interface': self.bind_interface,
10499            'egress_filter': self.egress_filter,
10500            'healthy': self.healthy,
10501            'hostname': self.hostname,
10502            'id': self.id,
10503            'key_type': self.key_type,
10504            'name': self.name,
10505            'port': self.port,
10506            'port_forwarding': self.port_forwarding,
10507            'port_override': self.port_override,
10508            'remote_identity_group_id': self.remote_identity_group_id,
10509            'remote_identity_healthcheck_username':
10510            self.remote_identity_healthcheck_username,
10511            'secret_store_id': self.secret_store_id,
10512            'tags': self.tags,
10513            'username': self.username,
10514        }
10515
10516    @classmethod
10517    def from_dict(cls, d):
10518        return cls(
10519            allow_deprecated_key_exchanges=d.get(
10520                'allow_deprecated_key_exchanges'),
10521            bind_interface=d.get('bind_interface'),
10522            egress_filter=d.get('egress_filter'),
10523            healthy=d.get('healthy'),
10524            hostname=d.get('hostname'),
10525            id=d.get('id'),
10526            key_type=d.get('key_type'),
10527            name=d.get('name'),
10528            port=d.get('port'),
10529            port_forwarding=d.get('port_forwarding'),
10530            port_override=d.get('port_override'),
10531            remote_identity_group_id=d.get('remote_identity_group_id'),
10532            remote_identity_healthcheck_username=d.get(
10533                'remote_identity_healthcheck_username'),
10534            secret_store_id=d.get('secret_store_id'),
10535            tags=d.get('tags'),
10536            username=d.get('username'),
10537        )
10538
10539
10540class SSHCustomerKey:
10541    __slots__ = [
10542        'allow_deprecated_key_exchanges',
10543        'bind_interface',
10544        'egress_filter',
10545        'healthy',
10546        'hostname',
10547        'id',
10548        'name',
10549        'port',
10550        'port_forwarding',
10551        'port_override',
10552        'private_key',
10553        'secret_store_id',
10554        'tags',
10555        'username',
10556    ]
10557
10558    def __init__(
10559        self,
10560        allow_deprecated_key_exchanges=None,
10561        bind_interface=None,
10562        egress_filter=None,
10563        healthy=None,
10564        hostname=None,
10565        id=None,
10566        name=None,
10567        port=None,
10568        port_forwarding=None,
10569        port_override=None,
10570        private_key=None,
10571        secret_store_id=None,
10572        tags=None,
10573        username=None,
10574    ):
10575        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10576        self.bind_interface = bind_interface if bind_interface is not None else ''
10577        '''
10578         Bind interface
10579        '''
10580        self.egress_filter = egress_filter if egress_filter is not None else ''
10581        '''
10582         A filter applied to the routing logic to pin datasource to nodes.
10583        '''
10584        self.healthy = healthy if healthy is not None else False
10585        '''
10586         True if the datasource is reachable and the credentials are valid.
10587        '''
10588        self.hostname = hostname if hostname is not None else ''
10589        self.id = id if id is not None else ''
10590        '''
10591         Unique identifier of the Resource.
10592        '''
10593        self.name = name if name is not None else ''
10594        '''
10595         Unique human-readable name of the Resource.
10596        '''
10597        self.port = port if port is not None else 0
10598        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10599        self.port_override = port_override if port_override is not None else 0
10600        self.private_key = private_key if private_key is not None else ''
10601        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10602        '''
10603         ID of the secret store containing credentials for this resource, if any.
10604        '''
10605        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10606        '''
10607         Tags is a map of key, value pairs.
10608        '''
10609        self.username = username if username is not None else ''
10610
10611    def __repr__(self):
10612        return '<sdm.SSHCustomerKey ' + \
10613            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10614            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10615            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10616            'healthy: ' + repr(self.healthy) + ' ' +\
10617            'hostname: ' + repr(self.hostname) + ' ' +\
10618            'id: ' + repr(self.id) + ' ' +\
10619            'name: ' + repr(self.name) + ' ' +\
10620            'port: ' + repr(self.port) + ' ' +\
10621            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10622            'port_override: ' + repr(self.port_override) + ' ' +\
10623            'private_key: ' + repr(self.private_key) + ' ' +\
10624            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10625            'tags: ' + repr(self.tags) + ' ' +\
10626            'username: ' + repr(self.username) + ' ' +\
10627            '>'
10628
10629    def to_dict(self):
10630        return {
10631            'allow_deprecated_key_exchanges':
10632            self.allow_deprecated_key_exchanges,
10633            'bind_interface': self.bind_interface,
10634            'egress_filter': self.egress_filter,
10635            'healthy': self.healthy,
10636            'hostname': self.hostname,
10637            'id': self.id,
10638            'name': self.name,
10639            'port': self.port,
10640            'port_forwarding': self.port_forwarding,
10641            'port_override': self.port_override,
10642            'private_key': self.private_key,
10643            'secret_store_id': self.secret_store_id,
10644            'tags': self.tags,
10645            'username': self.username,
10646        }
10647
10648    @classmethod
10649    def from_dict(cls, d):
10650        return cls(
10651            allow_deprecated_key_exchanges=d.get(
10652                'allow_deprecated_key_exchanges'),
10653            bind_interface=d.get('bind_interface'),
10654            egress_filter=d.get('egress_filter'),
10655            healthy=d.get('healthy'),
10656            hostname=d.get('hostname'),
10657            id=d.get('id'),
10658            name=d.get('name'),
10659            port=d.get('port'),
10660            port_forwarding=d.get('port_forwarding'),
10661            port_override=d.get('port_override'),
10662            private_key=d.get('private_key'),
10663            secret_store_id=d.get('secret_store_id'),
10664            tags=d.get('tags'),
10665            username=d.get('username'),
10666        )
10667
10668
10669class SecretStoreCreateResponse:
10670    '''
10671         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10672    '''
10673    __slots__ = [
10674        'meta',
10675        'rate_limit',
10676        'secret_store',
10677    ]
10678
10679    def __init__(
10680        self,
10681        meta=None,
10682        rate_limit=None,
10683        secret_store=None,
10684    ):
10685        self.meta = meta if meta is not None else None
10686        '''
10687         Reserved for future use.
10688        '''
10689        self.rate_limit = rate_limit if rate_limit is not None else None
10690        '''
10691         Rate limit information.
10692        '''
10693        self.secret_store = secret_store if secret_store is not None else None
10694        '''
10695         The created SecretStore.
10696        '''
10697
10698    def __repr__(self):
10699        return '<sdm.SecretStoreCreateResponse ' + \
10700            'meta: ' + repr(self.meta) + ' ' +\
10701            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10702            'secret_store: ' + repr(self.secret_store) + ' ' +\
10703            '>'
10704
10705    def to_dict(self):
10706        return {
10707            'meta': self.meta,
10708            'rate_limit': self.rate_limit,
10709            'secret_store': self.secret_store,
10710        }
10711
10712    @classmethod
10713    def from_dict(cls, d):
10714        return cls(
10715            meta=d.get('meta'),
10716            rate_limit=d.get('rate_limit'),
10717            secret_store=d.get('secret_store'),
10718        )
10719
10720
10721class SecretStoreDeleteResponse:
10722    '''
10723         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
10724    '''
10725    __slots__ = [
10726        'meta',
10727        'rate_limit',
10728    ]
10729
10730    def __init__(
10731        self,
10732        meta=None,
10733        rate_limit=None,
10734    ):
10735        self.meta = meta if meta is not None else None
10736        '''
10737         Reserved for future use.
10738        '''
10739        self.rate_limit = rate_limit if rate_limit is not None else None
10740        '''
10741         Rate limit information.
10742        '''
10743
10744    def __repr__(self):
10745        return '<sdm.SecretStoreDeleteResponse ' + \
10746            'meta: ' + repr(self.meta) + ' ' +\
10747            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10748            '>'
10749
10750    def to_dict(self):
10751        return {
10752            'meta': self.meta,
10753            'rate_limit': self.rate_limit,
10754        }
10755
10756    @classmethod
10757    def from_dict(cls, d):
10758        return cls(
10759            meta=d.get('meta'),
10760            rate_limit=d.get('rate_limit'),
10761        )
10762
10763
10764class SecretStoreGetResponse:
10765    '''
10766         SecretStoreGetResponse returns a requested SecretStore.
10767    '''
10768    __slots__ = [
10769        'meta',
10770        'rate_limit',
10771        'secret_store',
10772    ]
10773
10774    def __init__(
10775        self,
10776        meta=None,
10777        rate_limit=None,
10778        secret_store=None,
10779    ):
10780        self.meta = meta if meta is not None else None
10781        '''
10782         Reserved for future use.
10783        '''
10784        self.rate_limit = rate_limit if rate_limit is not None else None
10785        '''
10786         Rate limit information.
10787        '''
10788        self.secret_store = secret_store if secret_store is not None else None
10789        '''
10790         The requested SecretStore.
10791        '''
10792
10793    def __repr__(self):
10794        return '<sdm.SecretStoreGetResponse ' + \
10795            'meta: ' + repr(self.meta) + ' ' +\
10796            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10797            'secret_store: ' + repr(self.secret_store) + ' ' +\
10798            '>'
10799
10800    def to_dict(self):
10801        return {
10802            'meta': self.meta,
10803            'rate_limit': self.rate_limit,
10804            'secret_store': self.secret_store,
10805        }
10806
10807    @classmethod
10808    def from_dict(cls, d):
10809        return cls(
10810            meta=d.get('meta'),
10811            rate_limit=d.get('rate_limit'),
10812            secret_store=d.get('secret_store'),
10813        )
10814
10815
10816class SecretStoreUpdateResponse:
10817    '''
10818         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
10819     a SecretStoreUpdateRequest.
10820    '''
10821    __slots__ = [
10822        'meta',
10823        'rate_limit',
10824        'secret_store',
10825    ]
10826
10827    def __init__(
10828        self,
10829        meta=None,
10830        rate_limit=None,
10831        secret_store=None,
10832    ):
10833        self.meta = meta if meta is not None else None
10834        '''
10835         Reserved for future use.
10836        '''
10837        self.rate_limit = rate_limit if rate_limit is not None else None
10838        '''
10839         Rate limit information.
10840        '''
10841        self.secret_store = secret_store if secret_store is not None else None
10842        '''
10843         The updated SecretStore.
10844        '''
10845
10846    def __repr__(self):
10847        return '<sdm.SecretStoreUpdateResponse ' + \
10848            'meta: ' + repr(self.meta) + ' ' +\
10849            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10850            'secret_store: ' + repr(self.secret_store) + ' ' +\
10851            '>'
10852
10853    def to_dict(self):
10854        return {
10855            'meta': self.meta,
10856            'rate_limit': self.rate_limit,
10857            'secret_store': self.secret_store,
10858        }
10859
10860    @classmethod
10861    def from_dict(cls, d):
10862        return cls(
10863            meta=d.get('meta'),
10864            rate_limit=d.get('rate_limit'),
10865            secret_store=d.get('secret_store'),
10866        )
10867
10868
10869class Service:
10870    '''
10871         A Service is a service account that can connect to resources they are granted
10872     directly, or granted via roles. Services are typically automated jobs.
10873    '''
10874    __slots__ = [
10875        'id',
10876        'name',
10877        'suspended',
10878        'tags',
10879    ]
10880
10881    def __init__(
10882        self,
10883        id=None,
10884        name=None,
10885        suspended=None,
10886        tags=None,
10887    ):
10888        self.id = id if id is not None else ''
10889        '''
10890         Unique identifier of the Service.
10891        '''
10892        self.name = name if name is not None else ''
10893        '''
10894         Unique human-readable name of the Service.
10895        '''
10896        self.suspended = suspended if suspended is not None else False
10897        '''
10898         The Service's suspended state.
10899        '''
10900        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10901        '''
10902         Tags is a map of key, value pairs.
10903        '''
10904
10905    def __repr__(self):
10906        return '<sdm.Service ' + \
10907            'id: ' + repr(self.id) + ' ' +\
10908            'name: ' + repr(self.name) + ' ' +\
10909            'suspended: ' + repr(self.suspended) + ' ' +\
10910            'tags: ' + repr(self.tags) + ' ' +\
10911            '>'
10912
10913    def to_dict(self):
10914        return {
10915            'id': self.id,
10916            'name': self.name,
10917            'suspended': self.suspended,
10918            'tags': self.tags,
10919        }
10920
10921    @classmethod
10922    def from_dict(cls, d):
10923        return cls(
10924            id=d.get('id'),
10925            name=d.get('name'),
10926            suspended=d.get('suspended'),
10927            tags=d.get('tags'),
10928        )
10929
10930
10931class SingleStore:
10932    __slots__ = [
10933        'bind_interface',
10934        'database',
10935        'egress_filter',
10936        'healthy',
10937        'hostname',
10938        'id',
10939        'name',
10940        'password',
10941        'port',
10942        'port_override',
10943        'secret_store_id',
10944        'tags',
10945        'username',
10946    ]
10947
10948    def __init__(
10949        self,
10950        bind_interface=None,
10951        database=None,
10952        egress_filter=None,
10953        healthy=None,
10954        hostname=None,
10955        id=None,
10956        name=None,
10957        password=None,
10958        port=None,
10959        port_override=None,
10960        secret_store_id=None,
10961        tags=None,
10962        username=None,
10963    ):
10964        self.bind_interface = bind_interface if bind_interface is not None else ''
10965        '''
10966         Bind interface
10967        '''
10968        self.database = database if database is not None else ''
10969        self.egress_filter = egress_filter if egress_filter is not None else ''
10970        '''
10971         A filter applied to the routing logic to pin datasource to nodes.
10972        '''
10973        self.healthy = healthy if healthy is not None else False
10974        '''
10975         True if the datasource is reachable and the credentials are valid.
10976        '''
10977        self.hostname = hostname if hostname is not None else ''
10978        self.id = id if id is not None else ''
10979        '''
10980         Unique identifier of the Resource.
10981        '''
10982        self.name = name if name is not None else ''
10983        '''
10984         Unique human-readable name of the Resource.
10985        '''
10986        self.password = password if password is not None else ''
10987        self.port = port if port is not None else 0
10988        self.port_override = port_override if port_override is not None else 0
10989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10990        '''
10991         ID of the secret store containing credentials for this resource, if any.
10992        '''
10993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10994        '''
10995         Tags is a map of key, value pairs.
10996        '''
10997        self.username = username if username is not None else ''
10998
10999    def __repr__(self):
11000        return '<sdm.SingleStore ' + \
11001            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11002            'database: ' + repr(self.database) + ' ' +\
11003            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11004            'healthy: ' + repr(self.healthy) + ' ' +\
11005            'hostname: ' + repr(self.hostname) + ' ' +\
11006            'id: ' + repr(self.id) + ' ' +\
11007            'name: ' + repr(self.name) + ' ' +\
11008            'password: ' + repr(self.password) + ' ' +\
11009            'port: ' + repr(self.port) + ' ' +\
11010            'port_override: ' + repr(self.port_override) + ' ' +\
11011            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11012            'tags: ' + repr(self.tags) + ' ' +\
11013            'username: ' + repr(self.username) + ' ' +\
11014            '>'
11015
11016    def to_dict(self):
11017        return {
11018            'bind_interface': self.bind_interface,
11019            'database': self.database,
11020            'egress_filter': self.egress_filter,
11021            'healthy': self.healthy,
11022            'hostname': self.hostname,
11023            'id': self.id,
11024            'name': self.name,
11025            'password': self.password,
11026            'port': self.port,
11027            'port_override': self.port_override,
11028            'secret_store_id': self.secret_store_id,
11029            'tags': self.tags,
11030            'username': self.username,
11031        }
11032
11033    @classmethod
11034    def from_dict(cls, d):
11035        return cls(
11036            bind_interface=d.get('bind_interface'),
11037            database=d.get('database'),
11038            egress_filter=d.get('egress_filter'),
11039            healthy=d.get('healthy'),
11040            hostname=d.get('hostname'),
11041            id=d.get('id'),
11042            name=d.get('name'),
11043            password=d.get('password'),
11044            port=d.get('port'),
11045            port_override=d.get('port_override'),
11046            secret_store_id=d.get('secret_store_id'),
11047            tags=d.get('tags'),
11048            username=d.get('username'),
11049        )
11050
11051
11052class Snowflake:
11053    __slots__ = [
11054        'bind_interface',
11055        'database',
11056        'egress_filter',
11057        'healthy',
11058        'hostname',
11059        'id',
11060        'name',
11061        'password',
11062        'port_override',
11063        'schema',
11064        'secret_store_id',
11065        'tags',
11066        'username',
11067    ]
11068
11069    def __init__(
11070        self,
11071        bind_interface=None,
11072        database=None,
11073        egress_filter=None,
11074        healthy=None,
11075        hostname=None,
11076        id=None,
11077        name=None,
11078        password=None,
11079        port_override=None,
11080        schema=None,
11081        secret_store_id=None,
11082        tags=None,
11083        username=None,
11084    ):
11085        self.bind_interface = bind_interface if bind_interface is not None else ''
11086        '''
11087         Bind interface
11088        '''
11089        self.database = database if database is not None else ''
11090        self.egress_filter = egress_filter if egress_filter is not None else ''
11091        '''
11092         A filter applied to the routing logic to pin datasource to nodes.
11093        '''
11094        self.healthy = healthy if healthy is not None else False
11095        '''
11096         True if the datasource is reachable and the credentials are valid.
11097        '''
11098        self.hostname = hostname if hostname is not None else ''
11099        self.id = id if id is not None else ''
11100        '''
11101         Unique identifier of the Resource.
11102        '''
11103        self.name = name if name is not None else ''
11104        '''
11105         Unique human-readable name of the Resource.
11106        '''
11107        self.password = password if password is not None else ''
11108        self.port_override = port_override if port_override is not None else 0
11109        self.schema = schema if schema is not None else ''
11110        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11111        '''
11112         ID of the secret store containing credentials for this resource, if any.
11113        '''
11114        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11115        '''
11116         Tags is a map of key, value pairs.
11117        '''
11118        self.username = username if username is not None else ''
11119
11120    def __repr__(self):
11121        return '<sdm.Snowflake ' + \
11122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11123            'database: ' + repr(self.database) + ' ' +\
11124            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11125            'healthy: ' + repr(self.healthy) + ' ' +\
11126            'hostname: ' + repr(self.hostname) + ' ' +\
11127            'id: ' + repr(self.id) + ' ' +\
11128            'name: ' + repr(self.name) + ' ' +\
11129            'password: ' + repr(self.password) + ' ' +\
11130            'port_override: ' + repr(self.port_override) + ' ' +\
11131            'schema: ' + repr(self.schema) + ' ' +\
11132            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11133            'tags: ' + repr(self.tags) + ' ' +\
11134            'username: ' + repr(self.username) + ' ' +\
11135            '>'
11136
11137    def to_dict(self):
11138        return {
11139            'bind_interface': self.bind_interface,
11140            'database': self.database,
11141            'egress_filter': self.egress_filter,
11142            'healthy': self.healthy,
11143            'hostname': self.hostname,
11144            'id': self.id,
11145            'name': self.name,
11146            'password': self.password,
11147            'port_override': self.port_override,
11148            'schema': self.schema,
11149            'secret_store_id': self.secret_store_id,
11150            'tags': self.tags,
11151            'username': self.username,
11152        }
11153
11154    @classmethod
11155    def from_dict(cls, d):
11156        return cls(
11157            bind_interface=d.get('bind_interface'),
11158            database=d.get('database'),
11159            egress_filter=d.get('egress_filter'),
11160            healthy=d.get('healthy'),
11161            hostname=d.get('hostname'),
11162            id=d.get('id'),
11163            name=d.get('name'),
11164            password=d.get('password'),
11165            port_override=d.get('port_override'),
11166            schema=d.get('schema'),
11167            secret_store_id=d.get('secret_store_id'),
11168            tags=d.get('tags'),
11169            username=d.get('username'),
11170        )
11171
11172
11173class Sybase:
11174    __slots__ = [
11175        'bind_interface',
11176        'egress_filter',
11177        'healthy',
11178        'hostname',
11179        'id',
11180        'name',
11181        'password',
11182        'port',
11183        'port_override',
11184        'secret_store_id',
11185        'tags',
11186        'username',
11187    ]
11188
11189    def __init__(
11190        self,
11191        bind_interface=None,
11192        egress_filter=None,
11193        healthy=None,
11194        hostname=None,
11195        id=None,
11196        name=None,
11197        password=None,
11198        port=None,
11199        port_override=None,
11200        secret_store_id=None,
11201        tags=None,
11202        username=None,
11203    ):
11204        self.bind_interface = bind_interface if bind_interface is not None else ''
11205        '''
11206         Bind interface
11207        '''
11208        self.egress_filter = egress_filter if egress_filter is not None else ''
11209        '''
11210         A filter applied to the routing logic to pin datasource to nodes.
11211        '''
11212        self.healthy = healthy if healthy is not None else False
11213        '''
11214         True if the datasource is reachable and the credentials are valid.
11215        '''
11216        self.hostname = hostname if hostname is not None else ''
11217        self.id = id if id is not None else ''
11218        '''
11219         Unique identifier of the Resource.
11220        '''
11221        self.name = name if name is not None else ''
11222        '''
11223         Unique human-readable name of the Resource.
11224        '''
11225        self.password = password if password is not None else ''
11226        self.port = port if port is not None else 0
11227        self.port_override = port_override if port_override is not None else 0
11228        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11229        '''
11230         ID of the secret store containing credentials for this resource, if any.
11231        '''
11232        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11233        '''
11234         Tags is a map of key, value pairs.
11235        '''
11236        self.username = username if username is not None else ''
11237
11238    def __repr__(self):
11239        return '<sdm.Sybase ' + \
11240            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11241            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11242            'healthy: ' + repr(self.healthy) + ' ' +\
11243            'hostname: ' + repr(self.hostname) + ' ' +\
11244            'id: ' + repr(self.id) + ' ' +\
11245            'name: ' + repr(self.name) + ' ' +\
11246            'password: ' + repr(self.password) + ' ' +\
11247            'port: ' + repr(self.port) + ' ' +\
11248            'port_override: ' + repr(self.port_override) + ' ' +\
11249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11250            'tags: ' + repr(self.tags) + ' ' +\
11251            'username: ' + repr(self.username) + ' ' +\
11252            '>'
11253
11254    def to_dict(self):
11255        return {
11256            'bind_interface': self.bind_interface,
11257            'egress_filter': self.egress_filter,
11258            'healthy': self.healthy,
11259            'hostname': self.hostname,
11260            'id': self.id,
11261            'name': self.name,
11262            'password': self.password,
11263            'port': self.port,
11264            'port_override': self.port_override,
11265            'secret_store_id': self.secret_store_id,
11266            'tags': self.tags,
11267            'username': self.username,
11268        }
11269
11270    @classmethod
11271    def from_dict(cls, d):
11272        return cls(
11273            bind_interface=d.get('bind_interface'),
11274            egress_filter=d.get('egress_filter'),
11275            healthy=d.get('healthy'),
11276            hostname=d.get('hostname'),
11277            id=d.get('id'),
11278            name=d.get('name'),
11279            password=d.get('password'),
11280            port=d.get('port'),
11281            port_override=d.get('port_override'),
11282            secret_store_id=d.get('secret_store_id'),
11283            tags=d.get('tags'),
11284            username=d.get('username'),
11285        )
11286
11287
11288class SybaseIQ:
11289    __slots__ = [
11290        'bind_interface',
11291        'egress_filter',
11292        'healthy',
11293        'hostname',
11294        'id',
11295        'name',
11296        'password',
11297        'port',
11298        'port_override',
11299        'secret_store_id',
11300        'tags',
11301        'username',
11302    ]
11303
11304    def __init__(
11305        self,
11306        bind_interface=None,
11307        egress_filter=None,
11308        healthy=None,
11309        hostname=None,
11310        id=None,
11311        name=None,
11312        password=None,
11313        port=None,
11314        port_override=None,
11315        secret_store_id=None,
11316        tags=None,
11317        username=None,
11318    ):
11319        self.bind_interface = bind_interface if bind_interface is not None else ''
11320        '''
11321         Bind interface
11322        '''
11323        self.egress_filter = egress_filter if egress_filter is not None else ''
11324        '''
11325         A filter applied to the routing logic to pin datasource to nodes.
11326        '''
11327        self.healthy = healthy if healthy is not None else False
11328        '''
11329         True if the datasource is reachable and the credentials are valid.
11330        '''
11331        self.hostname = hostname if hostname is not None else ''
11332        self.id = id if id is not None else ''
11333        '''
11334         Unique identifier of the Resource.
11335        '''
11336        self.name = name if name is not None else ''
11337        '''
11338         Unique human-readable name of the Resource.
11339        '''
11340        self.password = password if password is not None else ''
11341        self.port = port if port is not None else 0
11342        self.port_override = port_override if port_override is not None else 0
11343        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11344        '''
11345         ID of the secret store containing credentials for this resource, if any.
11346        '''
11347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11348        '''
11349         Tags is a map of key, value pairs.
11350        '''
11351        self.username = username if username is not None else ''
11352
11353    def __repr__(self):
11354        return '<sdm.SybaseIQ ' + \
11355            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11356            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11357            'healthy: ' + repr(self.healthy) + ' ' +\
11358            'hostname: ' + repr(self.hostname) + ' ' +\
11359            'id: ' + repr(self.id) + ' ' +\
11360            'name: ' + repr(self.name) + ' ' +\
11361            'password: ' + repr(self.password) + ' ' +\
11362            'port: ' + repr(self.port) + ' ' +\
11363            'port_override: ' + repr(self.port_override) + ' ' +\
11364            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11365            'tags: ' + repr(self.tags) + ' ' +\
11366            'username: ' + repr(self.username) + ' ' +\
11367            '>'
11368
11369    def to_dict(self):
11370        return {
11371            'bind_interface': self.bind_interface,
11372            'egress_filter': self.egress_filter,
11373            'healthy': self.healthy,
11374            'hostname': self.hostname,
11375            'id': self.id,
11376            'name': self.name,
11377            'password': self.password,
11378            'port': self.port,
11379            'port_override': self.port_override,
11380            'secret_store_id': self.secret_store_id,
11381            'tags': self.tags,
11382            'username': self.username,
11383        }
11384
11385    @classmethod
11386    def from_dict(cls, d):
11387        return cls(
11388            bind_interface=d.get('bind_interface'),
11389            egress_filter=d.get('egress_filter'),
11390            healthy=d.get('healthy'),
11391            hostname=d.get('hostname'),
11392            id=d.get('id'),
11393            name=d.get('name'),
11394            password=d.get('password'),
11395            port=d.get('port'),
11396            port_override=d.get('port_override'),
11397            secret_store_id=d.get('secret_store_id'),
11398            tags=d.get('tags'),
11399            username=d.get('username'),
11400        )
11401
11402
11403class Tag:
11404    __slots__ = [
11405        'name',
11406        'value',
11407    ]
11408
11409    def __init__(
11410        self,
11411        name=None,
11412        value=None,
11413    ):
11414        self.name = name if name is not None else ''
11415        self.value = value if value is not None else ''
11416
11417    def __repr__(self):
11418        return '<sdm.Tag ' + \
11419            'name: ' + repr(self.name) + ' ' +\
11420            'value: ' + repr(self.value) + ' ' +\
11421            '>'
11422
11423    def to_dict(self):
11424        return {
11425            'name': self.name,
11426            'value': self.value,
11427        }
11428
11429    @classmethod
11430    def from_dict(cls, d):
11431        return cls(
11432            name=d.get('name'),
11433            value=d.get('value'),
11434        )
11435
11436
11437class Teradata:
11438    __slots__ = [
11439        'bind_interface',
11440        'egress_filter',
11441        'healthy',
11442        'hostname',
11443        'id',
11444        'name',
11445        'password',
11446        'port',
11447        'port_override',
11448        'secret_store_id',
11449        'tags',
11450        'username',
11451    ]
11452
11453    def __init__(
11454        self,
11455        bind_interface=None,
11456        egress_filter=None,
11457        healthy=None,
11458        hostname=None,
11459        id=None,
11460        name=None,
11461        password=None,
11462        port=None,
11463        port_override=None,
11464        secret_store_id=None,
11465        tags=None,
11466        username=None,
11467    ):
11468        self.bind_interface = bind_interface if bind_interface is not None else ''
11469        '''
11470         Bind interface
11471        '''
11472        self.egress_filter = egress_filter if egress_filter is not None else ''
11473        '''
11474         A filter applied to the routing logic to pin datasource to nodes.
11475        '''
11476        self.healthy = healthy if healthy is not None else False
11477        '''
11478         True if the datasource is reachable and the credentials are valid.
11479        '''
11480        self.hostname = hostname if hostname is not None else ''
11481        self.id = id if id is not None else ''
11482        '''
11483         Unique identifier of the Resource.
11484        '''
11485        self.name = name if name is not None else ''
11486        '''
11487         Unique human-readable name of the Resource.
11488        '''
11489        self.password = password if password is not None else ''
11490        self.port = port if port is not None else 0
11491        self.port_override = port_override if port_override is not None else 0
11492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11493        '''
11494         ID of the secret store containing credentials for this resource, if any.
11495        '''
11496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11497        '''
11498         Tags is a map of key, value pairs.
11499        '''
11500        self.username = username if username is not None else ''
11501
11502    def __repr__(self):
11503        return '<sdm.Teradata ' + \
11504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11506            'healthy: ' + repr(self.healthy) + ' ' +\
11507            'hostname: ' + repr(self.hostname) + ' ' +\
11508            'id: ' + repr(self.id) + ' ' +\
11509            'name: ' + repr(self.name) + ' ' +\
11510            'password: ' + repr(self.password) + ' ' +\
11511            'port: ' + repr(self.port) + ' ' +\
11512            'port_override: ' + repr(self.port_override) + ' ' +\
11513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11514            'tags: ' + repr(self.tags) + ' ' +\
11515            'username: ' + repr(self.username) + ' ' +\
11516            '>'
11517
11518    def to_dict(self):
11519        return {
11520            'bind_interface': self.bind_interface,
11521            'egress_filter': self.egress_filter,
11522            'healthy': self.healthy,
11523            'hostname': self.hostname,
11524            'id': self.id,
11525            'name': self.name,
11526            'password': self.password,
11527            'port': self.port,
11528            'port_override': self.port_override,
11529            'secret_store_id': self.secret_store_id,
11530            'tags': self.tags,
11531            'username': self.username,
11532        }
11533
11534    @classmethod
11535    def from_dict(cls, d):
11536        return cls(
11537            bind_interface=d.get('bind_interface'),
11538            egress_filter=d.get('egress_filter'),
11539            healthy=d.get('healthy'),
11540            hostname=d.get('hostname'),
11541            id=d.get('id'),
11542            name=d.get('name'),
11543            password=d.get('password'),
11544            port=d.get('port'),
11545            port_override=d.get('port_override'),
11546            secret_store_id=d.get('secret_store_id'),
11547            tags=d.get('tags'),
11548            username=d.get('username'),
11549        )
11550
11551
11552class UpdateResponseMetadata:
11553    '''
11554         UpdateResponseMetadata is reserved for future use.
11555    '''
11556    __slots__ = []
11557
11558    def __init__(self, ):
11559        pass
11560
11561    def __repr__(self):
11562        return '<sdm.UpdateResponseMetadata ' + \
11563            '>'
11564
11565    def to_dict(self):
11566        return {}
11567
11568    @classmethod
11569    def from_dict(cls, d):
11570        return cls()
11571
11572
11573class User:
11574    '''
11575         A User can connect to resources they are granted directly, or granted
11576     via roles.
11577    '''
11578    __slots__ = [
11579        'email',
11580        'first_name',
11581        'id',
11582        'last_name',
11583        'suspended',
11584        'tags',
11585    ]
11586
11587    def __init__(
11588        self,
11589        email=None,
11590        first_name=None,
11591        id=None,
11592        last_name=None,
11593        suspended=None,
11594        tags=None,
11595    ):
11596        self.email = email if email is not None else ''
11597        '''
11598         The User's email address. Must be unique.
11599        '''
11600        self.first_name = first_name if first_name is not None else ''
11601        '''
11602         The User's first name.
11603        '''
11604        self.id = id if id is not None else ''
11605        '''
11606         Unique identifier of the User.
11607        '''
11608        self.last_name = last_name if last_name is not None else ''
11609        '''
11610         The User's last name.
11611        '''
11612        self.suspended = suspended if suspended is not None else False
11613        '''
11614         The User's suspended state.
11615        '''
11616        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11617        '''
11618         Tags is a map of key, value pairs.
11619        '''
11620
11621    def __repr__(self):
11622        return '<sdm.User ' + \
11623            'email: ' + repr(self.email) + ' ' +\
11624            'first_name: ' + repr(self.first_name) + ' ' +\
11625            'id: ' + repr(self.id) + ' ' +\
11626            'last_name: ' + repr(self.last_name) + ' ' +\
11627            'suspended: ' + repr(self.suspended) + ' ' +\
11628            'tags: ' + repr(self.tags) + ' ' +\
11629            '>'
11630
11631    def to_dict(self):
11632        return {
11633            'email': self.email,
11634            'first_name': self.first_name,
11635            'id': self.id,
11636            'last_name': self.last_name,
11637            'suspended': self.suspended,
11638            'tags': self.tags,
11639        }
11640
11641    @classmethod
11642    def from_dict(cls, d):
11643        return cls(
11644            email=d.get('email'),
11645            first_name=d.get('first_name'),
11646            id=d.get('id'),
11647            last_name=d.get('last_name'),
11648            suspended=d.get('suspended'),
11649            tags=d.get('tags'),
11650        )
11651
11652
11653class VaultAppRoleStore:
11654    __slots__ = [
11655        'id',
11656        'name',
11657        'namespace',
11658        'server_address',
11659        'tags',
11660    ]
11661
11662    def __init__(
11663        self,
11664        id=None,
11665        name=None,
11666        namespace=None,
11667        server_address=None,
11668        tags=None,
11669    ):
11670        self.id = id if id is not None else ''
11671        '''
11672         Unique identifier of the SecretStore.
11673        '''
11674        self.name = name if name is not None else ''
11675        '''
11676         Unique human-readable name of the SecretStore.
11677        '''
11678        self.namespace = namespace if namespace is not None else ''
11679        self.server_address = server_address if server_address is not None else ''
11680        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11681        '''
11682         Tags is a map of key, value pairs.
11683        '''
11684
11685    def __repr__(self):
11686        return '<sdm.VaultAppRoleStore ' + \
11687            'id: ' + repr(self.id) + ' ' +\
11688            'name: ' + repr(self.name) + ' ' +\
11689            'namespace: ' + repr(self.namespace) + ' ' +\
11690            'server_address: ' + repr(self.server_address) + ' ' +\
11691            'tags: ' + repr(self.tags) + ' ' +\
11692            '>'
11693
11694    def to_dict(self):
11695        return {
11696            'id': self.id,
11697            'name': self.name,
11698            'namespace': self.namespace,
11699            'server_address': self.server_address,
11700            'tags': self.tags,
11701        }
11702
11703    @classmethod
11704    def from_dict(cls, d):
11705        return cls(
11706            id=d.get('id'),
11707            name=d.get('name'),
11708            namespace=d.get('namespace'),
11709            server_address=d.get('server_address'),
11710            tags=d.get('tags'),
11711        )
11712
11713
11714class VaultTLSStore:
11715    __slots__ = [
11716        'ca_cert_path',
11717        'client_cert_path',
11718        'client_key_path',
11719        'id',
11720        'name',
11721        'namespace',
11722        'server_address',
11723        'tags',
11724    ]
11725
11726    def __init__(
11727        self,
11728        ca_cert_path=None,
11729        client_cert_path=None,
11730        client_key_path=None,
11731        id=None,
11732        name=None,
11733        namespace=None,
11734        server_address=None,
11735        tags=None,
11736    ):
11737        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11738        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11739        self.client_key_path = client_key_path if client_key_path is not None else ''
11740        self.id = id if id is not None else ''
11741        '''
11742         Unique identifier of the SecretStore.
11743        '''
11744        self.name = name if name is not None else ''
11745        '''
11746         Unique human-readable name of the SecretStore.
11747        '''
11748        self.namespace = namespace if namespace is not None else ''
11749        self.server_address = server_address if server_address is not None else ''
11750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11751        '''
11752         Tags is a map of key, value pairs.
11753        '''
11754
11755    def __repr__(self):
11756        return '<sdm.VaultTLSStore ' + \
11757            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
11758            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
11759            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
11760            'id: ' + repr(self.id) + ' ' +\
11761            'name: ' + repr(self.name) + ' ' +\
11762            'namespace: ' + repr(self.namespace) + ' ' +\
11763            'server_address: ' + repr(self.server_address) + ' ' +\
11764            'tags: ' + repr(self.tags) + ' ' +\
11765            '>'
11766
11767    def to_dict(self):
11768        return {
11769            'ca_cert_path': self.ca_cert_path,
11770            'client_cert_path': self.client_cert_path,
11771            'client_key_path': self.client_key_path,
11772            'id': self.id,
11773            'name': self.name,
11774            'namespace': self.namespace,
11775            'server_address': self.server_address,
11776            'tags': self.tags,
11777        }
11778
11779    @classmethod
11780    def from_dict(cls, d):
11781        return cls(
11782            ca_cert_path=d.get('ca_cert_path'),
11783            client_cert_path=d.get('client_cert_path'),
11784            client_key_path=d.get('client_key_path'),
11785            id=d.get('id'),
11786            name=d.get('name'),
11787            namespace=d.get('namespace'),
11788            server_address=d.get('server_address'),
11789            tags=d.get('tags'),
11790        )
11791
11792
11793class VaultTokenStore:
11794    __slots__ = [
11795        'id',
11796        'name',
11797        'namespace',
11798        'server_address',
11799        'tags',
11800    ]
11801
11802    def __init__(
11803        self,
11804        id=None,
11805        name=None,
11806        namespace=None,
11807        server_address=None,
11808        tags=None,
11809    ):
11810        self.id = id if id is not None else ''
11811        '''
11812         Unique identifier of the SecretStore.
11813        '''
11814        self.name = name if name is not None else ''
11815        '''
11816         Unique human-readable name of the SecretStore.
11817        '''
11818        self.namespace = namespace if namespace is not None else ''
11819        self.server_address = server_address if server_address is not None else ''
11820        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11821        '''
11822         Tags is a map of key, value pairs.
11823        '''
11824
11825    def __repr__(self):
11826        return '<sdm.VaultTokenStore ' + \
11827            'id: ' + repr(self.id) + ' ' +\
11828            'name: ' + repr(self.name) + ' ' +\
11829            'namespace: ' + repr(self.namespace) + ' ' +\
11830            'server_address: ' + repr(self.server_address) + ' ' +\
11831            'tags: ' + repr(self.tags) + ' ' +\
11832            '>'
11833
11834    def to_dict(self):
11835        return {
11836            'id': self.id,
11837            'name': self.name,
11838            'namespace': self.namespace,
11839            'server_address': self.server_address,
11840            'tags': self.tags,
11841        }
11842
11843    @classmethod
11844    def from_dict(cls, d):
11845        return cls(
11846            id=d.get('id'),
11847            name=d.get('name'),
11848            namespace=d.get('namespace'),
11849            server_address=d.get('server_address'),
11850            tags=d.get('tags'),
11851        )
11852
11853
11854def _porcelain_zero_value_tags():
11855    return {}
11856
11857
11858def _porcelain_zero_value_access_rules():
11859    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSStore:
785class AWSStore:
786    __slots__ = [
787        'id',
788        'name',
789        'region',
790        'tags',
791    ]
792
793    def __init__(
794        self,
795        id=None,
796        name=None,
797        region=None,
798        tags=None,
799    ):
800        self.id = id if id is not None else ''
801        '''
802         Unique identifier of the SecretStore.
803        '''
804        self.name = name if name is not None else ''
805        '''
806         Unique human-readable name of the SecretStore.
807        '''
808        self.region = region if region is not None else ''
809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
810        '''
811         Tags is a map of key, value pairs.
812        '''
813
814    def __repr__(self):
815        return '<sdm.AWSStore ' + \
816            'id: ' + repr(self.id) + ' ' +\
817            'name: ' + repr(self.name) + ' ' +\
818            'region: ' + repr(self.region) + ' ' +\
819            'tags: ' + repr(self.tags) + ' ' +\
820            '>'
821
822    def to_dict(self):
823        return {
824            'id': self.id,
825            'name': self.name,
826            'region': self.region,
827            'tags': self.tags,
828        }
829
830    @classmethod
831    def from_dict(cls, d):
832        return cls(
833            id=d.get('id'),
834            name=d.get('name'),
835            region=d.get('region'),
836            tags=d.get('tags'),
837        )
AWSStore(id=None, name=None, region=None, tags=None)
793    def __init__(
794        self,
795        id=None,
796        name=None,
797        region=None,
798        tags=None,
799    ):
800        self.id = id if id is not None else ''
801        '''
802         Unique identifier of the SecretStore.
803        '''
804        self.name = name if name is not None else ''
805        '''
806         Unique human-readable name of the SecretStore.
807        '''
808        self.region = region if region is not None else ''
809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
810        '''
811         Tags is a map of key, value pairs.
812        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
822    def to_dict(self):
823        return {
824            'id': self.id,
825            'name': self.name,
826            'region': self.region,
827            'tags': self.tags,
828        }
@classmethod
def from_dict(cls, d)
830    @classmethod
831    def from_dict(cls, d):
832        return cls(
833            id=d.get('id'),
834            name=d.get('name'),
835            region=d.get('region'),
836            tags=d.get('tags'),
837        )
class AccountAttachment:
840class AccountAttachment:
841    '''
842         AccountAttachments assign an account to a role.
843    '''
844    __slots__ = [
845        'account_id',
846        'id',
847        'role_id',
848    ]
849
850    def __init__(
851        self,
852        account_id=None,
853        id=None,
854        role_id=None,
855    ):
856        self.account_id = account_id if account_id is not None else ''
857        '''
858         The id of the account of this AccountAttachment.
859        '''
860        self.id = id if id is not None else ''
861        '''
862         Unique identifier of the AccountAttachment.
863        '''
864        self.role_id = role_id if role_id is not None else ''
865        '''
866         The id of the attached role of this AccountAttachment.
867        '''
868
869    def __repr__(self):
870        return '<sdm.AccountAttachment ' + \
871            'account_id: ' + repr(self.account_id) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'role_id: ' + repr(self.role_id) + ' ' +\
874            '>'
875
876    def to_dict(self):
877        return {
878            'account_id': self.account_id,
879            'id': self.id,
880            'role_id': self.role_id,
881        }
882
883    @classmethod
884    def from_dict(cls, d):
885        return cls(
886            account_id=d.get('account_id'),
887            id=d.get('id'),
888            role_id=d.get('role_id'),
889        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
850    def __init__(
851        self,
852        account_id=None,
853        id=None,
854        role_id=None,
855    ):
856        self.account_id = account_id if account_id is not None else ''
857        '''
858         The id of the account of this AccountAttachment.
859        '''
860        self.id = id if id is not None else ''
861        '''
862         Unique identifier of the AccountAttachment.
863        '''
864        self.role_id = role_id if role_id is not None else ''
865        '''
866         The id of the attached role of this AccountAttachment.
867        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
876    def to_dict(self):
877        return {
878            'account_id': self.account_id,
879            'id': self.id,
880            'role_id': self.role_id,
881        }
@classmethod
def from_dict(cls, d)
883    @classmethod
884    def from_dict(cls, d):
885        return cls(
886            account_id=d.get('account_id'),
887            id=d.get('id'),
888            role_id=d.get('role_id'),
889        )
class AccountAttachmentCreateResponse:
892class AccountAttachmentCreateResponse:
893    '''
894         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
895    '''
896    __slots__ = [
897        'account_attachment',
898        'meta',
899        'rate_limit',
900    ]
901
902    def __init__(
903        self,
904        account_attachment=None,
905        meta=None,
906        rate_limit=None,
907    ):
908        self.account_attachment = account_attachment if account_attachment is not None else None
909        '''
910         The created AccountAttachment.
911        '''
912        self.meta = meta if meta is not None else None
913        '''
914         Reserved for future use.
915        '''
916        self.rate_limit = rate_limit if rate_limit is not None else None
917        '''
918         Rate limit information.
919        '''
920
921    def __repr__(self):
922        return '<sdm.AccountAttachmentCreateResponse ' + \
923            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
924            'meta: ' + repr(self.meta) + ' ' +\
925            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
926            '>'
927
928    def to_dict(self):
929        return {
930            'account_attachment': self.account_attachment,
931            'meta': self.meta,
932            'rate_limit': self.rate_limit,
933        }
934
935    @classmethod
936    def from_dict(cls, d):
937        return cls(
938            account_attachment=d.get('account_attachment'),
939            meta=d.get('meta'),
940            rate_limit=d.get('rate_limit'),
941        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
902    def __init__(
903        self,
904        account_attachment=None,
905        meta=None,
906        rate_limit=None,
907    ):
908        self.account_attachment = account_attachment if account_attachment is not None else None
909        '''
910         The created AccountAttachment.
911        '''
912        self.meta = meta if meta is not None else None
913        '''
914         Reserved for future use.
915        '''
916        self.rate_limit = rate_limit if rate_limit is not None else None
917        '''
918         Rate limit information.
919        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
928    def to_dict(self):
929        return {
930            'account_attachment': self.account_attachment,
931            'meta': self.meta,
932            'rate_limit': self.rate_limit,
933        }
@classmethod
def from_dict(cls, d)
935    @classmethod
936    def from_dict(cls, d):
937        return cls(
938            account_attachment=d.get('account_attachment'),
939            meta=d.get('meta'),
940            rate_limit=d.get('rate_limit'),
941        )
class AccountAttachmentDeleteResponse:
944class AccountAttachmentDeleteResponse:
945    '''
946         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
947    '''
948    __slots__ = [
949        'meta',
950        'rate_limit',
951    ]
952
953    def __init__(
954        self,
955        meta=None,
956        rate_limit=None,
957    ):
958        self.meta = meta if meta is not None else None
959        '''
960         Reserved for future use.
961        '''
962        self.rate_limit = rate_limit if rate_limit is not None else None
963        '''
964         Rate limit information.
965        '''
966
967    def __repr__(self):
968        return '<sdm.AccountAttachmentDeleteResponse ' + \
969            'meta: ' + repr(self.meta) + ' ' +\
970            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
971            '>'
972
973    def to_dict(self):
974        return {
975            'meta': self.meta,
976            'rate_limit': self.rate_limit,
977        }
978
979    @classmethod
980    def from_dict(cls, d):
981        return cls(
982            meta=d.get('meta'),
983            rate_limit=d.get('rate_limit'),
984        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
953    def __init__(
954        self,
955        meta=None,
956        rate_limit=None,
957    ):
958        self.meta = meta if meta is not None else None
959        '''
960         Reserved for future use.
961        '''
962        self.rate_limit = rate_limit if rate_limit is not None else None
963        '''
964         Rate limit information.
965        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
973    def to_dict(self):
974        return {
975            'meta': self.meta,
976            'rate_limit': self.rate_limit,
977        }
@classmethod
def from_dict(cls, d)
979    @classmethod
980    def from_dict(cls, d):
981        return cls(
982            meta=d.get('meta'),
983            rate_limit=d.get('rate_limit'),
984        )
class AccountAttachmentGetResponse:
 987class AccountAttachmentGetResponse:
 988    '''
 989         AccountAttachmentGetResponse returns a requested AccountAttachment.
 990    '''
 991    __slots__ = [
 992        'account_attachment',
 993        'meta',
 994        'rate_limit',
 995    ]
 996
 997    def __init__(
 998        self,
 999        account_attachment=None,
1000        meta=None,
1001        rate_limit=None,
1002    ):
1003        self.account_attachment = account_attachment if account_attachment is not None else None
1004        '''
1005         The requested AccountAttachment.
1006        '''
1007        self.meta = meta if meta is not None else None
1008        '''
1009         Reserved for future use.
1010        '''
1011        self.rate_limit = rate_limit if rate_limit is not None else None
1012        '''
1013         Rate limit information.
1014        '''
1015
1016    def __repr__(self):
1017        return '<sdm.AccountAttachmentGetResponse ' + \
1018            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1019            'meta: ' + repr(self.meta) + ' ' +\
1020            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1021            '>'
1022
1023    def to_dict(self):
1024        return {
1025            'account_attachment': self.account_attachment,
1026            'meta': self.meta,
1027            'rate_limit': self.rate_limit,
1028        }
1029
1030    @classmethod
1031    def from_dict(cls, d):
1032        return cls(
1033            account_attachment=d.get('account_attachment'),
1034            meta=d.get('meta'),
1035            rate_limit=d.get('rate_limit'),
1036        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
 997    def __init__(
 998        self,
 999        account_attachment=None,
1000        meta=None,
1001        rate_limit=None,
1002    ):
1003        self.account_attachment = account_attachment if account_attachment is not None else None
1004        '''
1005         The requested AccountAttachment.
1006        '''
1007        self.meta = meta if meta is not None else None
1008        '''
1009         Reserved for future use.
1010        '''
1011        self.rate_limit = rate_limit if rate_limit is not None else None
1012        '''
1013         Rate limit information.
1014        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1023    def to_dict(self):
1024        return {
1025            'account_attachment': self.account_attachment,
1026            'meta': self.meta,
1027            'rate_limit': self.rate_limit,
1028        }
@classmethod
def from_dict(cls, d)
1030    @classmethod
1031    def from_dict(cls, d):
1032        return cls(
1033            account_attachment=d.get('account_attachment'),
1034            meta=d.get('meta'),
1035            rate_limit=d.get('rate_limit'),
1036        )
class AccountCreateResponse:
1039class AccountCreateResponse:
1040    '''
1041         AccountCreateResponse reports how the Accounts were created in the system.
1042    '''
1043    __slots__ = [
1044        'account',
1045        'meta',
1046        'rate_limit',
1047        'token',
1048    ]
1049
1050    def __init__(
1051        self,
1052        account=None,
1053        meta=None,
1054        rate_limit=None,
1055        token=None,
1056    ):
1057        self.account = account if account is not None else None
1058        '''
1059         The created Account.
1060        '''
1061        self.meta = meta if meta is not None else None
1062        '''
1063         Reserved for future use.
1064        '''
1065        self.rate_limit = rate_limit if rate_limit is not None else None
1066        '''
1067         Rate limit information.
1068        '''
1069        self.token = token if token is not None else ''
1070        '''
1071         The auth token generated for the Account. The Account will use this token to
1072         authenticate with the strongDM API.
1073        '''
1074
1075    def __repr__(self):
1076        return '<sdm.AccountCreateResponse ' + \
1077            'account: ' + repr(self.account) + ' ' +\
1078            'meta: ' + repr(self.meta) + ' ' +\
1079            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1080            'token: ' + repr(self.token) + ' ' +\
1081            '>'
1082
1083    def to_dict(self):
1084        return {
1085            'account': self.account,
1086            'meta': self.meta,
1087            'rate_limit': self.rate_limit,
1088            'token': self.token,
1089        }
1090
1091    @classmethod
1092    def from_dict(cls, d):
1093        return cls(
1094            account=d.get('account'),
1095            meta=d.get('meta'),
1096            rate_limit=d.get('rate_limit'),
1097            token=d.get('token'),
1098        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1050    def __init__(
1051        self,
1052        account=None,
1053        meta=None,
1054        rate_limit=None,
1055        token=None,
1056    ):
1057        self.account = account if account is not None else None
1058        '''
1059         The created Account.
1060        '''
1061        self.meta = meta if meta is not None else None
1062        '''
1063         Reserved for future use.
1064        '''
1065        self.rate_limit = rate_limit if rate_limit is not None else None
1066        '''
1067         Rate limit information.
1068        '''
1069        self.token = token if token is not None else ''
1070        '''
1071         The auth token generated for the Account. The Account will use this token to
1072         authenticate with the strongDM API.
1073        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1083    def to_dict(self):
1084        return {
1085            'account': self.account,
1086            'meta': self.meta,
1087            'rate_limit': self.rate_limit,
1088            'token': self.token,
1089        }
@classmethod
def from_dict(cls, d)
1091    @classmethod
1092    def from_dict(cls, d):
1093        return cls(
1094            account=d.get('account'),
1095            meta=d.get('meta'),
1096            rate_limit=d.get('rate_limit'),
1097            token=d.get('token'),
1098        )
class AccountDeleteResponse:
1101class AccountDeleteResponse:
1102    '''
1103         AccountDeleteResponse returns information about a Account that was deleted.
1104    '''
1105    __slots__ = [
1106        'meta',
1107        'rate_limit',
1108    ]
1109
1110    def __init__(
1111        self,
1112        meta=None,
1113        rate_limit=None,
1114    ):
1115        self.meta = meta if meta is not None else None
1116        '''
1117         Reserved for future use.
1118        '''
1119        self.rate_limit = rate_limit if rate_limit is not None else None
1120        '''
1121         Rate limit information.
1122        '''
1123
1124    def __repr__(self):
1125        return '<sdm.AccountDeleteResponse ' + \
1126            'meta: ' + repr(self.meta) + ' ' +\
1127            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1128            '>'
1129
1130    def to_dict(self):
1131        return {
1132            'meta': self.meta,
1133            'rate_limit': self.rate_limit,
1134        }
1135
1136    @classmethod
1137    def from_dict(cls, d):
1138        return cls(
1139            meta=d.get('meta'),
1140            rate_limit=d.get('rate_limit'),
1141        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1110    def __init__(
1111        self,
1112        meta=None,
1113        rate_limit=None,
1114    ):
1115        self.meta = meta if meta is not None else None
1116        '''
1117         Reserved for future use.
1118        '''
1119        self.rate_limit = rate_limit if rate_limit is not None else None
1120        '''
1121         Rate limit information.
1122        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1130    def to_dict(self):
1131        return {
1132            'meta': self.meta,
1133            'rate_limit': self.rate_limit,
1134        }
@classmethod
def from_dict(cls, d)
1136    @classmethod
1137    def from_dict(cls, d):
1138        return cls(
1139            meta=d.get('meta'),
1140            rate_limit=d.get('rate_limit'),
1141        )
class AccountGetResponse:
1144class AccountGetResponse:
1145    '''
1146         AccountGetResponse returns a requested Account.
1147    '''
1148    __slots__ = [
1149        'account',
1150        'meta',
1151        'rate_limit',
1152    ]
1153
1154    def __init__(
1155        self,
1156        account=None,
1157        meta=None,
1158        rate_limit=None,
1159    ):
1160        self.account = account if account is not None else None
1161        '''
1162         The requested Account.
1163        '''
1164        self.meta = meta if meta is not None else None
1165        '''
1166         Reserved for future use.
1167        '''
1168        self.rate_limit = rate_limit if rate_limit is not None else None
1169        '''
1170         Rate limit information.
1171        '''
1172
1173    def __repr__(self):
1174        return '<sdm.AccountGetResponse ' + \
1175            'account: ' + repr(self.account) + ' ' +\
1176            'meta: ' + repr(self.meta) + ' ' +\
1177            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1178            '>'
1179
1180    def to_dict(self):
1181        return {
1182            'account': self.account,
1183            'meta': self.meta,
1184            'rate_limit': self.rate_limit,
1185        }
1186
1187    @classmethod
1188    def from_dict(cls, d):
1189        return cls(
1190            account=d.get('account'),
1191            meta=d.get('meta'),
1192            rate_limit=d.get('rate_limit'),
1193        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1154    def __init__(
1155        self,
1156        account=None,
1157        meta=None,
1158        rate_limit=None,
1159    ):
1160        self.account = account if account is not None else None
1161        '''
1162         The requested Account.
1163        '''
1164        self.meta = meta if meta is not None else None
1165        '''
1166         Reserved for future use.
1167        '''
1168        self.rate_limit = rate_limit if rate_limit is not None else None
1169        '''
1170         Rate limit information.
1171        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1180    def to_dict(self):
1181        return {
1182            'account': self.account,
1183            'meta': self.meta,
1184            'rate_limit': self.rate_limit,
1185        }
@classmethod
def from_dict(cls, d)
1187    @classmethod
1188    def from_dict(cls, d):
1189        return cls(
1190            account=d.get('account'),
1191            meta=d.get('meta'),
1192            rate_limit=d.get('rate_limit'),
1193        )
class AccountGrant:
1196class AccountGrant:
1197    '''
1198         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1199    '''
1200    __slots__ = [
1201        'account_id',
1202        'id',
1203        'resource_id',
1204        'start_from',
1205        'valid_until',
1206    ]
1207
1208    def __init__(
1209        self,
1210        account_id=None,
1211        id=None,
1212        resource_id=None,
1213        start_from=None,
1214        valid_until=None,
1215    ):
1216        self.account_id = account_id if account_id is not None else ''
1217        '''
1218         The account ID of this AccountGrant.
1219        '''
1220        self.id = id if id is not None else ''
1221        '''
1222         Unique identifier of the AccountGrant.
1223        '''
1224        self.resource_id = resource_id if resource_id is not None else ''
1225        '''
1226         The resource ID of this AccountGrant.
1227        '''
1228        self.start_from = start_from if start_from is not None else None
1229        '''
1230         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1231        '''
1232        self.valid_until = valid_until if valid_until is not None else None
1233        '''
1234         The timestamp when the resource grant will expire.
1235        '''
1236
1237    def __repr__(self):
1238        return '<sdm.AccountGrant ' + \
1239            'account_id: ' + repr(self.account_id) + ' ' +\
1240            'id: ' + repr(self.id) + ' ' +\
1241            'resource_id: ' + repr(self.resource_id) + ' ' +\
1242            'start_from: ' + repr(self.start_from) + ' ' +\
1243            'valid_until: ' + repr(self.valid_until) + ' ' +\
1244            '>'
1245
1246    def to_dict(self):
1247        return {
1248            'account_id': self.account_id,
1249            'id': self.id,
1250            'resource_id': self.resource_id,
1251            'start_from': self.start_from,
1252            'valid_until': self.valid_until,
1253        }
1254
1255    @classmethod
1256    def from_dict(cls, d):
1257        return cls(
1258            account_id=d.get('account_id'),
1259            id=d.get('id'),
1260            resource_id=d.get('resource_id'),
1261            start_from=d.get('start_from'),
1262            valid_until=d.get('valid_until'),
1263        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1208    def __init__(
1209        self,
1210        account_id=None,
1211        id=None,
1212        resource_id=None,
1213        start_from=None,
1214        valid_until=None,
1215    ):
1216        self.account_id = account_id if account_id is not None else ''
1217        '''
1218         The account ID of this AccountGrant.
1219        '''
1220        self.id = id if id is not None else ''
1221        '''
1222         Unique identifier of the AccountGrant.
1223        '''
1224        self.resource_id = resource_id if resource_id is not None else ''
1225        '''
1226         The resource ID of this AccountGrant.
1227        '''
1228        self.start_from = start_from if start_from is not None else None
1229        '''
1230         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1231        '''
1232        self.valid_until = valid_until if valid_until is not None else None
1233        '''
1234         The timestamp when the resource grant will expire.
1235        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1246    def to_dict(self):
1247        return {
1248            'account_id': self.account_id,
1249            'id': self.id,
1250            'resource_id': self.resource_id,
1251            'start_from': self.start_from,
1252            'valid_until': self.valid_until,
1253        }
@classmethod
def from_dict(cls, d)
1255    @classmethod
1256    def from_dict(cls, d):
1257        return cls(
1258            account_id=d.get('account_id'),
1259            id=d.get('id'),
1260            resource_id=d.get('resource_id'),
1261            start_from=d.get('start_from'),
1262            valid_until=d.get('valid_until'),
1263        )
class AccountGrantCreateResponse:
1266class AccountGrantCreateResponse:
1267    '''
1268         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1269    '''
1270    __slots__ = [
1271        'account_grant',
1272        'meta',
1273        'rate_limit',
1274    ]
1275
1276    def __init__(
1277        self,
1278        account_grant=None,
1279        meta=None,
1280        rate_limit=None,
1281    ):
1282        self.account_grant = account_grant if account_grant is not None else None
1283        '''
1284         The created AccountGrant.
1285        '''
1286        self.meta = meta if meta is not None else None
1287        '''
1288         Reserved for future use.
1289        '''
1290        self.rate_limit = rate_limit if rate_limit is not None else None
1291        '''
1292         Rate limit information.
1293        '''
1294
1295    def __repr__(self):
1296        return '<sdm.AccountGrantCreateResponse ' + \
1297            'account_grant: ' + repr(self.account_grant) + ' ' +\
1298            'meta: ' + repr(self.meta) + ' ' +\
1299            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1300            '>'
1301
1302    def to_dict(self):
1303        return {
1304            'account_grant': self.account_grant,
1305            'meta': self.meta,
1306            'rate_limit': self.rate_limit,
1307        }
1308
1309    @classmethod
1310    def from_dict(cls, d):
1311        return cls(
1312            account_grant=d.get('account_grant'),
1313            meta=d.get('meta'),
1314            rate_limit=d.get('rate_limit'),
1315        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1276    def __init__(
1277        self,
1278        account_grant=None,
1279        meta=None,
1280        rate_limit=None,
1281    ):
1282        self.account_grant = account_grant if account_grant is not None else None
1283        '''
1284         The created AccountGrant.
1285        '''
1286        self.meta = meta if meta is not None else None
1287        '''
1288         Reserved for future use.
1289        '''
1290        self.rate_limit = rate_limit if rate_limit is not None else None
1291        '''
1292         Rate limit information.
1293        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1302    def to_dict(self):
1303        return {
1304            'account_grant': self.account_grant,
1305            'meta': self.meta,
1306            'rate_limit': self.rate_limit,
1307        }
@classmethod
def from_dict(cls, d)
1309    @classmethod
1310    def from_dict(cls, d):
1311        return cls(
1312            account_grant=d.get('account_grant'),
1313            meta=d.get('meta'),
1314            rate_limit=d.get('rate_limit'),
1315        )
class AccountGrantDeleteResponse:
1318class AccountGrantDeleteResponse:
1319    '''
1320         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1321    '''
1322    __slots__ = [
1323        'meta',
1324        'rate_limit',
1325    ]
1326
1327    def __init__(
1328        self,
1329        meta=None,
1330        rate_limit=None,
1331    ):
1332        self.meta = meta if meta is not None else None
1333        '''
1334         Reserved for future use.
1335        '''
1336        self.rate_limit = rate_limit if rate_limit is not None else None
1337        '''
1338         Rate limit information.
1339        '''
1340
1341    def __repr__(self):
1342        return '<sdm.AccountGrantDeleteResponse ' + \
1343            'meta: ' + repr(self.meta) + ' ' +\
1344            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1345            '>'
1346
1347    def to_dict(self):
1348        return {
1349            'meta': self.meta,
1350            'rate_limit': self.rate_limit,
1351        }
1352
1353    @classmethod
1354    def from_dict(cls, d):
1355        return cls(
1356            meta=d.get('meta'),
1357            rate_limit=d.get('rate_limit'),
1358        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1327    def __init__(
1328        self,
1329        meta=None,
1330        rate_limit=None,
1331    ):
1332        self.meta = meta if meta is not None else None
1333        '''
1334         Reserved for future use.
1335        '''
1336        self.rate_limit = rate_limit if rate_limit is not None else None
1337        '''
1338         Rate limit information.
1339        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1347    def to_dict(self):
1348        return {
1349            'meta': self.meta,
1350            'rate_limit': self.rate_limit,
1351        }
@classmethod
def from_dict(cls, d)
1353    @classmethod
1354    def from_dict(cls, d):
1355        return cls(
1356            meta=d.get('meta'),
1357            rate_limit=d.get('rate_limit'),
1358        )
class AccountGrantGetResponse:
1361class AccountGrantGetResponse:
1362    '''
1363         AccountGrantGetResponse returns a requested AccountGrant.
1364    '''
1365    __slots__ = [
1366        'account_grant',
1367        'meta',
1368        'rate_limit',
1369    ]
1370
1371    def __init__(
1372        self,
1373        account_grant=None,
1374        meta=None,
1375        rate_limit=None,
1376    ):
1377        self.account_grant = account_grant if account_grant is not None else None
1378        '''
1379         The requested AccountGrant.
1380        '''
1381        self.meta = meta if meta is not None else None
1382        '''
1383         Reserved for future use.
1384        '''
1385        self.rate_limit = rate_limit if rate_limit is not None else None
1386        '''
1387         Rate limit information.
1388        '''
1389
1390    def __repr__(self):
1391        return '<sdm.AccountGrantGetResponse ' + \
1392            'account_grant: ' + repr(self.account_grant) + ' ' +\
1393            'meta: ' + repr(self.meta) + ' ' +\
1394            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1395            '>'
1396
1397    def to_dict(self):
1398        return {
1399            'account_grant': self.account_grant,
1400            'meta': self.meta,
1401            'rate_limit': self.rate_limit,
1402        }
1403
1404    @classmethod
1405    def from_dict(cls, d):
1406        return cls(
1407            account_grant=d.get('account_grant'),
1408            meta=d.get('meta'),
1409            rate_limit=d.get('rate_limit'),
1410        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1371    def __init__(
1372        self,
1373        account_grant=None,
1374        meta=None,
1375        rate_limit=None,
1376    ):
1377        self.account_grant = account_grant if account_grant is not None else None
1378        '''
1379         The requested AccountGrant.
1380        '''
1381        self.meta = meta if meta is not None else None
1382        '''
1383         Reserved for future use.
1384        '''
1385        self.rate_limit = rate_limit if rate_limit is not None else None
1386        '''
1387         Rate limit information.
1388        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1397    def to_dict(self):
1398        return {
1399            'account_grant': self.account_grant,
1400            'meta': self.meta,
1401            'rate_limit': self.rate_limit,
1402        }
@classmethod
def from_dict(cls, d)
1404    @classmethod
1405    def from_dict(cls, d):
1406        return cls(
1407            account_grant=d.get('account_grant'),
1408            meta=d.get('meta'),
1409            rate_limit=d.get('rate_limit'),
1410        )
class AccountUpdateResponse:
1413class AccountUpdateResponse:
1414    '''
1415         AccountUpdateResponse returns the fields of a Account after it has been updated by
1416     a AccountUpdateRequest.
1417    '''
1418    __slots__ = [
1419        'account',
1420        'meta',
1421        'rate_limit',
1422    ]
1423
1424    def __init__(
1425        self,
1426        account=None,
1427        meta=None,
1428        rate_limit=None,
1429    ):
1430        self.account = account if account is not None else None
1431        '''
1432         The updated Account.
1433        '''
1434        self.meta = meta if meta is not None else None
1435        '''
1436         Reserved for future use.
1437        '''
1438        self.rate_limit = rate_limit if rate_limit is not None else None
1439        '''
1440         Rate limit information.
1441        '''
1442
1443    def __repr__(self):
1444        return '<sdm.AccountUpdateResponse ' + \
1445            'account: ' + repr(self.account) + ' ' +\
1446            'meta: ' + repr(self.meta) + ' ' +\
1447            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1448            '>'
1449
1450    def to_dict(self):
1451        return {
1452            'account': self.account,
1453            'meta': self.meta,
1454            'rate_limit': self.rate_limit,
1455        }
1456
1457    @classmethod
1458    def from_dict(cls, d):
1459        return cls(
1460            account=d.get('account'),
1461            meta=d.get('meta'),
1462            rate_limit=d.get('rate_limit'),
1463        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1424    def __init__(
1425        self,
1426        account=None,
1427        meta=None,
1428        rate_limit=None,
1429    ):
1430        self.account = account if account is not None else None
1431        '''
1432         The updated Account.
1433        '''
1434        self.meta = meta if meta is not None else None
1435        '''
1436         Reserved for future use.
1437        '''
1438        self.rate_limit = rate_limit if rate_limit is not None else None
1439        '''
1440         Rate limit information.
1441        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1450    def to_dict(self):
1451        return {
1452            'account': self.account,
1453            'meta': self.meta,
1454            'rate_limit': self.rate_limit,
1455        }
@classmethod
def from_dict(cls, d)
1457    @classmethod
1458    def from_dict(cls, d):
1459        return cls(
1460            account=d.get('account'),
1461            meta=d.get('meta'),
1462            rate_limit=d.get('rate_limit'),
1463        )
class AmazonEKS:
1466class AmazonEKS:
1467    __slots__ = [
1468        'access_key',
1469        'bind_interface',
1470        'certificate_authority',
1471        'cluster_name',
1472        'egress_filter',
1473        'endpoint',
1474        'healthcheck_namespace',
1475        'healthy',
1476        'id',
1477        'name',
1478        'region',
1479        'remote_identity_group_id',
1480        'remote_identity_healthcheck_username',
1481        'role_arn',
1482        'role_external_id',
1483        'secret_access_key',
1484        'secret_store_id',
1485        'tags',
1486    ]
1487
1488    def __init__(
1489        self,
1490        access_key=None,
1491        bind_interface=None,
1492        certificate_authority=None,
1493        cluster_name=None,
1494        egress_filter=None,
1495        endpoint=None,
1496        healthcheck_namespace=None,
1497        healthy=None,
1498        id=None,
1499        name=None,
1500        region=None,
1501        remote_identity_group_id=None,
1502        remote_identity_healthcheck_username=None,
1503        role_arn=None,
1504        role_external_id=None,
1505        secret_access_key=None,
1506        secret_store_id=None,
1507        tags=None,
1508    ):
1509        self.access_key = access_key if access_key is not None else ''
1510        self.bind_interface = bind_interface if bind_interface is not None else ''
1511        '''
1512         Bind interface
1513        '''
1514        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1515        self.cluster_name = cluster_name if cluster_name is not None else ''
1516        self.egress_filter = egress_filter if egress_filter is not None else ''
1517        '''
1518         A filter applied to the routing logic to pin datasource to nodes.
1519        '''
1520        self.endpoint = endpoint if endpoint is not None else ''
1521        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1522        '''
1523         The path used to check the health of your connection.  Defaults to `default`.
1524        '''
1525        self.healthy = healthy if healthy is not None else False
1526        '''
1527         True if the datasource is reachable and the credentials are valid.
1528        '''
1529        self.id = id if id is not None else ''
1530        '''
1531         Unique identifier of the Resource.
1532        '''
1533        self.name = name if name is not None else ''
1534        '''
1535         Unique human-readable name of the Resource.
1536        '''
1537        self.region = region if region is not None else ''
1538        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1539        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1540        self.role_arn = role_arn if role_arn is not None else ''
1541        self.role_external_id = role_external_id if role_external_id is not None else ''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1544        '''
1545         ID of the secret store containing credentials for this resource, if any.
1546        '''
1547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1548        '''
1549         Tags is a map of key, value pairs.
1550        '''
1551
1552    def __repr__(self):
1553        return '<sdm.AmazonEKS ' + \
1554            'access_key: ' + repr(self.access_key) + ' ' +\
1555            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1556            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1557            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1558            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1559            'endpoint: ' + repr(self.endpoint) + ' ' +\
1560            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1561            'healthy: ' + repr(self.healthy) + ' ' +\
1562            'id: ' + repr(self.id) + ' ' +\
1563            'name: ' + repr(self.name) + ' ' +\
1564            'region: ' + repr(self.region) + ' ' +\
1565            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1566            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1567            'role_arn: ' + repr(self.role_arn) + ' ' +\
1568            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1569            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1571            'tags: ' + repr(self.tags) + ' ' +\
1572            '>'
1573
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'bind_interface': self.bind_interface,
1578            'certificate_authority': self.certificate_authority,
1579            'cluster_name': self.cluster_name,
1580            'egress_filter': self.egress_filter,
1581            'endpoint': self.endpoint,
1582            'healthcheck_namespace': self.healthcheck_namespace,
1583            'healthy': self.healthy,
1584            'id': self.id,
1585            'name': self.name,
1586            'region': self.region,
1587            'remote_identity_group_id': self.remote_identity_group_id,
1588            'remote_identity_healthcheck_username':
1589            self.remote_identity_healthcheck_username,
1590            'role_arn': self.role_arn,
1591            'role_external_id': self.role_external_id,
1592            'secret_access_key': self.secret_access_key,
1593            'secret_store_id': self.secret_store_id,
1594            'tags': self.tags,
1595        }
1596
1597    @classmethod
1598    def from_dict(cls, d):
1599        return cls(
1600            access_key=d.get('access_key'),
1601            bind_interface=d.get('bind_interface'),
1602            certificate_authority=d.get('certificate_authority'),
1603            cluster_name=d.get('cluster_name'),
1604            egress_filter=d.get('egress_filter'),
1605            endpoint=d.get('endpoint'),
1606            healthcheck_namespace=d.get('healthcheck_namespace'),
1607            healthy=d.get('healthy'),
1608            id=d.get('id'),
1609            name=d.get('name'),
1610            region=d.get('region'),
1611            remote_identity_group_id=d.get('remote_identity_group_id'),
1612            remote_identity_healthcheck_username=d.get(
1613                'remote_identity_healthcheck_username'),
1614            role_arn=d.get('role_arn'),
1615            role_external_id=d.get('role_external_id'),
1616            secret_access_key=d.get('secret_access_key'),
1617            secret_store_id=d.get('secret_store_id'),
1618            tags=d.get('tags'),
1619        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1488    def __init__(
1489        self,
1490        access_key=None,
1491        bind_interface=None,
1492        certificate_authority=None,
1493        cluster_name=None,
1494        egress_filter=None,
1495        endpoint=None,
1496        healthcheck_namespace=None,
1497        healthy=None,
1498        id=None,
1499        name=None,
1500        region=None,
1501        remote_identity_group_id=None,
1502        remote_identity_healthcheck_username=None,
1503        role_arn=None,
1504        role_external_id=None,
1505        secret_access_key=None,
1506        secret_store_id=None,
1507        tags=None,
1508    ):
1509        self.access_key = access_key if access_key is not None else ''
1510        self.bind_interface = bind_interface if bind_interface is not None else ''
1511        '''
1512         Bind interface
1513        '''
1514        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1515        self.cluster_name = cluster_name if cluster_name is not None else ''
1516        self.egress_filter = egress_filter if egress_filter is not None else ''
1517        '''
1518         A filter applied to the routing logic to pin datasource to nodes.
1519        '''
1520        self.endpoint = endpoint if endpoint is not None else ''
1521        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1522        '''
1523         The path used to check the health of your connection.  Defaults to `default`.
1524        '''
1525        self.healthy = healthy if healthy is not None else False
1526        '''
1527         True if the datasource is reachable and the credentials are valid.
1528        '''
1529        self.id = id if id is not None else ''
1530        '''
1531         Unique identifier of the Resource.
1532        '''
1533        self.name = name if name is not None else ''
1534        '''
1535         Unique human-readable name of the Resource.
1536        '''
1537        self.region = region if region is not None else ''
1538        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1539        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1540        self.role_arn = role_arn if role_arn is not None else ''
1541        self.role_external_id = role_external_id if role_external_id is not None else ''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1544        '''
1545         ID of the secret store containing credentials for this resource, if any.
1546        '''
1547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1548        '''
1549         Tags is a map of key, value pairs.
1550        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'bind_interface': self.bind_interface,
1578            'certificate_authority': self.certificate_authority,
1579            'cluster_name': self.cluster_name,
1580            'egress_filter': self.egress_filter,
1581            'endpoint': self.endpoint,
1582            'healthcheck_namespace': self.healthcheck_namespace,
1583            'healthy': self.healthy,
1584            'id': self.id,
1585            'name': self.name,
1586            'region': self.region,
1587            'remote_identity_group_id': self.remote_identity_group_id,
1588            'remote_identity_healthcheck_username':
1589            self.remote_identity_healthcheck_username,
1590            'role_arn': self.role_arn,
1591            'role_external_id': self.role_external_id,
1592            'secret_access_key': self.secret_access_key,
1593            'secret_store_id': self.secret_store_id,
1594            'tags': self.tags,
1595        }
@classmethod
def from_dict(cls, d)
1597    @classmethod
1598    def from_dict(cls, d):
1599        return cls(
1600            access_key=d.get('access_key'),
1601            bind_interface=d.get('bind_interface'),
1602            certificate_authority=d.get('certificate_authority'),
1603            cluster_name=d.get('cluster_name'),
1604            egress_filter=d.get('egress_filter'),
1605            endpoint=d.get('endpoint'),
1606            healthcheck_namespace=d.get('healthcheck_namespace'),
1607            healthy=d.get('healthy'),
1608            id=d.get('id'),
1609            name=d.get('name'),
1610            region=d.get('region'),
1611            remote_identity_group_id=d.get('remote_identity_group_id'),
1612            remote_identity_healthcheck_username=d.get(
1613                'remote_identity_healthcheck_username'),
1614            role_arn=d.get('role_arn'),
1615            role_external_id=d.get('role_external_id'),
1616            secret_access_key=d.get('secret_access_key'),
1617            secret_store_id=d.get('secret_store_id'),
1618            tags=d.get('tags'),
1619        )
class AmazonEKSUserImpersonation:
1622class AmazonEKSUserImpersonation:
1623    __slots__ = [
1624        'access_key',
1625        'bind_interface',
1626        'certificate_authority',
1627        'cluster_name',
1628        'egress_filter',
1629        'endpoint',
1630        'healthcheck_namespace',
1631        'healthy',
1632        'id',
1633        'name',
1634        'region',
1635        'role_arn',
1636        'role_external_id',
1637        'secret_access_key',
1638        'secret_store_id',
1639        'tags',
1640    ]
1641
1642    def __init__(
1643        self,
1644        access_key=None,
1645        bind_interface=None,
1646        certificate_authority=None,
1647        cluster_name=None,
1648        egress_filter=None,
1649        endpoint=None,
1650        healthcheck_namespace=None,
1651        healthy=None,
1652        id=None,
1653        name=None,
1654        region=None,
1655        role_arn=None,
1656        role_external_id=None,
1657        secret_access_key=None,
1658        secret_store_id=None,
1659        tags=None,
1660    ):
1661        self.access_key = access_key if access_key is not None else ''
1662        self.bind_interface = bind_interface if bind_interface is not None else ''
1663        '''
1664         Bind interface
1665        '''
1666        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1667        self.cluster_name = cluster_name if cluster_name is not None else ''
1668        self.egress_filter = egress_filter if egress_filter is not None else ''
1669        '''
1670         A filter applied to the routing logic to pin datasource to nodes.
1671        '''
1672        self.endpoint = endpoint if endpoint is not None else ''
1673        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1674        '''
1675         The path used to check the health of your connection.  Defaults to `default`.
1676        '''
1677        self.healthy = healthy if healthy is not None else False
1678        '''
1679         True if the datasource is reachable and the credentials are valid.
1680        '''
1681        self.id = id if id is not None else ''
1682        '''
1683         Unique identifier of the Resource.
1684        '''
1685        self.name = name if name is not None else ''
1686        '''
1687         Unique human-readable name of the Resource.
1688        '''
1689        self.region = region if region is not None else ''
1690        self.role_arn = role_arn if role_arn is not None else ''
1691        self.role_external_id = role_external_id if role_external_id is not None else ''
1692        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1694        '''
1695         ID of the secret store containing credentials for this resource, if any.
1696        '''
1697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1698        '''
1699         Tags is a map of key, value pairs.
1700        '''
1701
1702    def __repr__(self):
1703        return '<sdm.AmazonEKSUserImpersonation ' + \
1704            'access_key: ' + repr(self.access_key) + ' ' +\
1705            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1706            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1707            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1709            'endpoint: ' + repr(self.endpoint) + ' ' +\
1710            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1711            'healthy: ' + repr(self.healthy) + ' ' +\
1712            'id: ' + repr(self.id) + ' ' +\
1713            'name: ' + repr(self.name) + ' ' +\
1714            'region: ' + repr(self.region) + ' ' +\
1715            'role_arn: ' + repr(self.role_arn) + ' ' +\
1716            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1717            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1718            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1719            'tags: ' + repr(self.tags) + ' ' +\
1720            '>'
1721
1722    def to_dict(self):
1723        return {
1724            'access_key': self.access_key,
1725            'bind_interface': self.bind_interface,
1726            'certificate_authority': self.certificate_authority,
1727            'cluster_name': self.cluster_name,
1728            'egress_filter': self.egress_filter,
1729            'endpoint': self.endpoint,
1730            'healthcheck_namespace': self.healthcheck_namespace,
1731            'healthy': self.healthy,
1732            'id': self.id,
1733            'name': self.name,
1734            'region': self.region,
1735            'role_arn': self.role_arn,
1736            'role_external_id': self.role_external_id,
1737            'secret_access_key': self.secret_access_key,
1738            'secret_store_id': self.secret_store_id,
1739            'tags': self.tags,
1740        }
1741
1742    @classmethod
1743    def from_dict(cls, d):
1744        return cls(
1745            access_key=d.get('access_key'),
1746            bind_interface=d.get('bind_interface'),
1747            certificate_authority=d.get('certificate_authority'),
1748            cluster_name=d.get('cluster_name'),
1749            egress_filter=d.get('egress_filter'),
1750            endpoint=d.get('endpoint'),
1751            healthcheck_namespace=d.get('healthcheck_namespace'),
1752            healthy=d.get('healthy'),
1753            id=d.get('id'),
1754            name=d.get('name'),
1755            region=d.get('region'),
1756            role_arn=d.get('role_arn'),
1757            role_external_id=d.get('role_external_id'),
1758            secret_access_key=d.get('secret_access_key'),
1759            secret_store_id=d.get('secret_store_id'),
1760            tags=d.get('tags'),
1761        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1642    def __init__(
1643        self,
1644        access_key=None,
1645        bind_interface=None,
1646        certificate_authority=None,
1647        cluster_name=None,
1648        egress_filter=None,
1649        endpoint=None,
1650        healthcheck_namespace=None,
1651        healthy=None,
1652        id=None,
1653        name=None,
1654        region=None,
1655        role_arn=None,
1656        role_external_id=None,
1657        secret_access_key=None,
1658        secret_store_id=None,
1659        tags=None,
1660    ):
1661        self.access_key = access_key if access_key is not None else ''
1662        self.bind_interface = bind_interface if bind_interface is not None else ''
1663        '''
1664         Bind interface
1665        '''
1666        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1667        self.cluster_name = cluster_name if cluster_name is not None else ''
1668        self.egress_filter = egress_filter if egress_filter is not None else ''
1669        '''
1670         A filter applied to the routing logic to pin datasource to nodes.
1671        '''
1672        self.endpoint = endpoint if endpoint is not None else ''
1673        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1674        '''
1675         The path used to check the health of your connection.  Defaults to `default`.
1676        '''
1677        self.healthy = healthy if healthy is not None else False
1678        '''
1679         True if the datasource is reachable and the credentials are valid.
1680        '''
1681        self.id = id if id is not None else ''
1682        '''
1683         Unique identifier of the Resource.
1684        '''
1685        self.name = name if name is not None else ''
1686        '''
1687         Unique human-readable name of the Resource.
1688        '''
1689        self.region = region if region is not None else ''
1690        self.role_arn = role_arn if role_arn is not None else ''
1691        self.role_external_id = role_external_id if role_external_id is not None else ''
1692        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1694        '''
1695         ID of the secret store containing credentials for this resource, if any.
1696        '''
1697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1698        '''
1699         Tags is a map of key, value pairs.
1700        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1722    def to_dict(self):
1723        return {
1724            'access_key': self.access_key,
1725            'bind_interface': self.bind_interface,
1726            'certificate_authority': self.certificate_authority,
1727            'cluster_name': self.cluster_name,
1728            'egress_filter': self.egress_filter,
1729            'endpoint': self.endpoint,
1730            'healthcheck_namespace': self.healthcheck_namespace,
1731            'healthy': self.healthy,
1732            'id': self.id,
1733            'name': self.name,
1734            'region': self.region,
1735            'role_arn': self.role_arn,
1736            'role_external_id': self.role_external_id,
1737            'secret_access_key': self.secret_access_key,
1738            'secret_store_id': self.secret_store_id,
1739            'tags': self.tags,
1740        }
@classmethod
def from_dict(cls, d)
1742    @classmethod
1743    def from_dict(cls, d):
1744        return cls(
1745            access_key=d.get('access_key'),
1746            bind_interface=d.get('bind_interface'),
1747            certificate_authority=d.get('certificate_authority'),
1748            cluster_name=d.get('cluster_name'),
1749            egress_filter=d.get('egress_filter'),
1750            endpoint=d.get('endpoint'),
1751            healthcheck_namespace=d.get('healthcheck_namespace'),
1752            healthy=d.get('healthy'),
1753            id=d.get('id'),
1754            name=d.get('name'),
1755            region=d.get('region'),
1756            role_arn=d.get('role_arn'),
1757            role_external_id=d.get('role_external_id'),
1758            secret_access_key=d.get('secret_access_key'),
1759            secret_store_id=d.get('secret_store_id'),
1760            tags=d.get('tags'),
1761        )
class AmazonES:
1764class AmazonES:
1765    __slots__ = [
1766        'access_key',
1767        'bind_interface',
1768        'egress_filter',
1769        'endpoint',
1770        'healthy',
1771        'id',
1772        'name',
1773        'port_override',
1774        'region',
1775        'role_arn',
1776        'role_external_id',
1777        'secret_access_key',
1778        'secret_store_id',
1779        'tags',
1780    ]
1781
1782    def __init__(
1783        self,
1784        access_key=None,
1785        bind_interface=None,
1786        egress_filter=None,
1787        endpoint=None,
1788        healthy=None,
1789        id=None,
1790        name=None,
1791        port_override=None,
1792        region=None,
1793        role_arn=None,
1794        role_external_id=None,
1795        secret_access_key=None,
1796        secret_store_id=None,
1797        tags=None,
1798    ):
1799        self.access_key = access_key if access_key is not None else ''
1800        self.bind_interface = bind_interface if bind_interface is not None else ''
1801        '''
1802         Bind interface
1803        '''
1804        self.egress_filter = egress_filter if egress_filter is not None else ''
1805        '''
1806         A filter applied to the routing logic to pin datasource to nodes.
1807        '''
1808        self.endpoint = endpoint if endpoint is not None else ''
1809        self.healthy = healthy if healthy is not None else False
1810        '''
1811         True if the datasource is reachable and the credentials are valid.
1812        '''
1813        self.id = id if id is not None else ''
1814        '''
1815         Unique identifier of the Resource.
1816        '''
1817        self.name = name if name is not None else ''
1818        '''
1819         Unique human-readable name of the Resource.
1820        '''
1821        self.port_override = port_override if port_override is not None else 0
1822        self.region = region if region is not None else ''
1823        self.role_arn = role_arn if role_arn is not None else ''
1824        self.role_external_id = role_external_id if role_external_id is not None else ''
1825        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1827        '''
1828         ID of the secret store containing credentials for this resource, if any.
1829        '''
1830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1831        '''
1832         Tags is a map of key, value pairs.
1833        '''
1834
1835    def __repr__(self):
1836        return '<sdm.AmazonES ' + \
1837            'access_key: ' + repr(self.access_key) + ' ' +\
1838            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1839            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1840            'endpoint: ' + repr(self.endpoint) + ' ' +\
1841            'healthy: ' + repr(self.healthy) + ' ' +\
1842            'id: ' + repr(self.id) + ' ' +\
1843            'name: ' + repr(self.name) + ' ' +\
1844            'port_override: ' + repr(self.port_override) + ' ' +\
1845            'region: ' + repr(self.region) + ' ' +\
1846            'role_arn: ' + repr(self.role_arn) + ' ' +\
1847            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1848            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1849            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1850            'tags: ' + repr(self.tags) + ' ' +\
1851            '>'
1852
1853    def to_dict(self):
1854        return {
1855            'access_key': self.access_key,
1856            'bind_interface': self.bind_interface,
1857            'egress_filter': self.egress_filter,
1858            'endpoint': self.endpoint,
1859            'healthy': self.healthy,
1860            'id': self.id,
1861            'name': self.name,
1862            'port_override': self.port_override,
1863            'region': self.region,
1864            'role_arn': self.role_arn,
1865            'role_external_id': self.role_external_id,
1866            'secret_access_key': self.secret_access_key,
1867            'secret_store_id': self.secret_store_id,
1868            'tags': self.tags,
1869        }
1870
1871    @classmethod
1872    def from_dict(cls, d):
1873        return cls(
1874            access_key=d.get('access_key'),
1875            bind_interface=d.get('bind_interface'),
1876            egress_filter=d.get('egress_filter'),
1877            endpoint=d.get('endpoint'),
1878            healthy=d.get('healthy'),
1879            id=d.get('id'),
1880            name=d.get('name'),
1881            port_override=d.get('port_override'),
1882            region=d.get('region'),
1883            role_arn=d.get('role_arn'),
1884            role_external_id=d.get('role_external_id'),
1885            secret_access_key=d.get('secret_access_key'),
1886            secret_store_id=d.get('secret_store_id'),
1887            tags=d.get('tags'),
1888        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1782    def __init__(
1783        self,
1784        access_key=None,
1785        bind_interface=None,
1786        egress_filter=None,
1787        endpoint=None,
1788        healthy=None,
1789        id=None,
1790        name=None,
1791        port_override=None,
1792        region=None,
1793        role_arn=None,
1794        role_external_id=None,
1795        secret_access_key=None,
1796        secret_store_id=None,
1797        tags=None,
1798    ):
1799        self.access_key = access_key if access_key is not None else ''
1800        self.bind_interface = bind_interface if bind_interface is not None else ''
1801        '''
1802         Bind interface
1803        '''
1804        self.egress_filter = egress_filter if egress_filter is not None else ''
1805        '''
1806         A filter applied to the routing logic to pin datasource to nodes.
1807        '''
1808        self.endpoint = endpoint if endpoint is not None else ''
1809        self.healthy = healthy if healthy is not None else False
1810        '''
1811         True if the datasource is reachable and the credentials are valid.
1812        '''
1813        self.id = id if id is not None else ''
1814        '''
1815         Unique identifier of the Resource.
1816        '''
1817        self.name = name if name is not None else ''
1818        '''
1819         Unique human-readable name of the Resource.
1820        '''
1821        self.port_override = port_override if port_override is not None else 0
1822        self.region = region if region is not None else ''
1823        self.role_arn = role_arn if role_arn is not None else ''
1824        self.role_external_id = role_external_id if role_external_id is not None else ''
1825        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1827        '''
1828         ID of the secret store containing credentials for this resource, if any.
1829        '''
1830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1831        '''
1832         Tags is a map of key, value pairs.
1833        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1853    def to_dict(self):
1854        return {
1855            'access_key': self.access_key,
1856            'bind_interface': self.bind_interface,
1857            'egress_filter': self.egress_filter,
1858            'endpoint': self.endpoint,
1859            'healthy': self.healthy,
1860            'id': self.id,
1861            'name': self.name,
1862            'port_override': self.port_override,
1863            'region': self.region,
1864            'role_arn': self.role_arn,
1865            'role_external_id': self.role_external_id,
1866            'secret_access_key': self.secret_access_key,
1867            'secret_store_id': self.secret_store_id,
1868            'tags': self.tags,
1869        }
@classmethod
def from_dict(cls, d)
1871    @classmethod
1872    def from_dict(cls, d):
1873        return cls(
1874            access_key=d.get('access_key'),
1875            bind_interface=d.get('bind_interface'),
1876            egress_filter=d.get('egress_filter'),
1877            endpoint=d.get('endpoint'),
1878            healthy=d.get('healthy'),
1879            id=d.get('id'),
1880            name=d.get('name'),
1881            port_override=d.get('port_override'),
1882            region=d.get('region'),
1883            role_arn=d.get('role_arn'),
1884            role_external_id=d.get('role_external_id'),
1885            secret_access_key=d.get('secret_access_key'),
1886            secret_store_id=d.get('secret_store_id'),
1887            tags=d.get('tags'),
1888        )
class AmazonMQAMQP091:
1891class AmazonMQAMQP091:
1892    __slots__ = [
1893        'bind_interface',
1894        'egress_filter',
1895        'healthy',
1896        'hostname',
1897        'id',
1898        'name',
1899        'password',
1900        'port',
1901        'port_override',
1902        'secret_store_id',
1903        'tags',
1904        'tls_required',
1905        'username',
1906    ]
1907
1908    def __init__(
1909        self,
1910        bind_interface=None,
1911        egress_filter=None,
1912        healthy=None,
1913        hostname=None,
1914        id=None,
1915        name=None,
1916        password=None,
1917        port=None,
1918        port_override=None,
1919        secret_store_id=None,
1920        tags=None,
1921        tls_required=None,
1922        username=None,
1923    ):
1924        self.bind_interface = bind_interface if bind_interface is not None else ''
1925        '''
1926         Bind interface
1927        '''
1928        self.egress_filter = egress_filter if egress_filter is not None else ''
1929        '''
1930         A filter applied to the routing logic to pin datasource to nodes.
1931        '''
1932        self.healthy = healthy if healthy is not None else False
1933        '''
1934         True if the datasource is reachable and the credentials are valid.
1935        '''
1936        self.hostname = hostname if hostname is not None else ''
1937        self.id = id if id is not None else ''
1938        '''
1939         Unique identifier of the Resource.
1940        '''
1941        self.name = name if name is not None else ''
1942        '''
1943         Unique human-readable name of the Resource.
1944        '''
1945        self.password = password if password is not None else ''
1946        self.port = port if port is not None else 0
1947        self.port_override = port_override if port_override is not None else 0
1948        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1949        '''
1950         ID of the secret store containing credentials for this resource, if any.
1951        '''
1952        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1953        '''
1954         Tags is a map of key, value pairs.
1955        '''
1956        self.tls_required = tls_required if tls_required is not None else False
1957        self.username = username if username is not None else ''
1958
1959    def __repr__(self):
1960        return '<sdm.AmazonMQAMQP091 ' + \
1961            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1962            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1963            'healthy: ' + repr(self.healthy) + ' ' +\
1964            'hostname: ' + repr(self.hostname) + ' ' +\
1965            'id: ' + repr(self.id) + ' ' +\
1966            'name: ' + repr(self.name) + ' ' +\
1967            'password: ' + repr(self.password) + ' ' +\
1968            'port: ' + repr(self.port) + ' ' +\
1969            'port_override: ' + repr(self.port_override) + ' ' +\
1970            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1971            'tags: ' + repr(self.tags) + ' ' +\
1972            'tls_required: ' + repr(self.tls_required) + ' ' +\
1973            'username: ' + repr(self.username) + ' ' +\
1974            '>'
1975
1976    def to_dict(self):
1977        return {
1978            'bind_interface': self.bind_interface,
1979            'egress_filter': self.egress_filter,
1980            'healthy': self.healthy,
1981            'hostname': self.hostname,
1982            'id': self.id,
1983            'name': self.name,
1984            'password': self.password,
1985            'port': self.port,
1986            'port_override': self.port_override,
1987            'secret_store_id': self.secret_store_id,
1988            'tags': self.tags,
1989            'tls_required': self.tls_required,
1990            'username': self.username,
1991        }
1992
1993    @classmethod
1994    def from_dict(cls, d):
1995        return cls(
1996            bind_interface=d.get('bind_interface'),
1997            egress_filter=d.get('egress_filter'),
1998            healthy=d.get('healthy'),
1999            hostname=d.get('hostname'),
2000            id=d.get('id'),
2001            name=d.get('name'),
2002            password=d.get('password'),
2003            port=d.get('port'),
2004            port_override=d.get('port_override'),
2005            secret_store_id=d.get('secret_store_id'),
2006            tags=d.get('tags'),
2007            tls_required=d.get('tls_required'),
2008            username=d.get('username'),
2009        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
1908    def __init__(
1909        self,
1910        bind_interface=None,
1911        egress_filter=None,
1912        healthy=None,
1913        hostname=None,
1914        id=None,
1915        name=None,
1916        password=None,
1917        port=None,
1918        port_override=None,
1919        secret_store_id=None,
1920        tags=None,
1921        tls_required=None,
1922        username=None,
1923    ):
1924        self.bind_interface = bind_interface if bind_interface is not None else ''
1925        '''
1926         Bind interface
1927        '''
1928        self.egress_filter = egress_filter if egress_filter is not None else ''
1929        '''
1930         A filter applied to the routing logic to pin datasource to nodes.
1931        '''
1932        self.healthy = healthy if healthy is not None else False
1933        '''
1934         True if the datasource is reachable and the credentials are valid.
1935        '''
1936        self.hostname = hostname if hostname is not None else ''
1937        self.id = id if id is not None else ''
1938        '''
1939         Unique identifier of the Resource.
1940        '''
1941        self.name = name if name is not None else ''
1942        '''
1943         Unique human-readable name of the Resource.
1944        '''
1945        self.password = password if password is not None else ''
1946        self.port = port if port is not None else 0
1947        self.port_override = port_override if port_override is not None else 0
1948        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1949        '''
1950         ID of the secret store containing credentials for this resource, if any.
1951        '''
1952        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1953        '''
1954         Tags is a map of key, value pairs.
1955        '''
1956        self.tls_required = tls_required if tls_required is not None else False
1957        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
1976    def to_dict(self):
1977        return {
1978            'bind_interface': self.bind_interface,
1979            'egress_filter': self.egress_filter,
1980            'healthy': self.healthy,
1981            'hostname': self.hostname,
1982            'id': self.id,
1983            'name': self.name,
1984            'password': self.password,
1985            'port': self.port,
1986            'port_override': self.port_override,
1987            'secret_store_id': self.secret_store_id,
1988            'tags': self.tags,
1989            'tls_required': self.tls_required,
1990            'username': self.username,
1991        }
@classmethod
def from_dict(cls, d)
1993    @classmethod
1994    def from_dict(cls, d):
1995        return cls(
1996            bind_interface=d.get('bind_interface'),
1997            egress_filter=d.get('egress_filter'),
1998            healthy=d.get('healthy'),
1999            hostname=d.get('hostname'),
2000            id=d.get('id'),
2001            name=d.get('name'),
2002            password=d.get('password'),
2003            port=d.get('port'),
2004            port_override=d.get('port_override'),
2005            secret_store_id=d.get('secret_store_id'),
2006            tags=d.get('tags'),
2007            tls_required=d.get('tls_required'),
2008            username=d.get('username'),
2009        )
class Athena:
2012class Athena:
2013    __slots__ = [
2014        'access_key',
2015        'bind_interface',
2016        'egress_filter',
2017        'healthy',
2018        'id',
2019        'name',
2020        'output',
2021        'port_override',
2022        'region',
2023        'role_arn',
2024        'role_external_id',
2025        'secret_access_key',
2026        'secret_store_id',
2027        'tags',
2028    ]
2029
2030    def __init__(
2031        self,
2032        access_key=None,
2033        bind_interface=None,
2034        egress_filter=None,
2035        healthy=None,
2036        id=None,
2037        name=None,
2038        output=None,
2039        port_override=None,
2040        region=None,
2041        role_arn=None,
2042        role_external_id=None,
2043        secret_access_key=None,
2044        secret_store_id=None,
2045        tags=None,
2046    ):
2047        self.access_key = access_key if access_key is not None else ''
2048        self.bind_interface = bind_interface if bind_interface is not None else ''
2049        '''
2050         Bind interface
2051        '''
2052        self.egress_filter = egress_filter if egress_filter is not None else ''
2053        '''
2054         A filter applied to the routing logic to pin datasource to nodes.
2055        '''
2056        self.healthy = healthy if healthy is not None else False
2057        '''
2058         True if the datasource is reachable and the credentials are valid.
2059        '''
2060        self.id = id if id is not None else ''
2061        '''
2062         Unique identifier of the Resource.
2063        '''
2064        self.name = name if name is not None else ''
2065        '''
2066         Unique human-readable name of the Resource.
2067        '''
2068        self.output = output if output is not None else ''
2069        self.port_override = port_override if port_override is not None else 0
2070        self.region = region if region is not None else ''
2071        self.role_arn = role_arn if role_arn is not None else ''
2072        self.role_external_id = role_external_id if role_external_id is not None else ''
2073        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2075        '''
2076         ID of the secret store containing credentials for this resource, if any.
2077        '''
2078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2079        '''
2080         Tags is a map of key, value pairs.
2081        '''
2082
2083    def __repr__(self):
2084        return '<sdm.Athena ' + \
2085            'access_key: ' + repr(self.access_key) + ' ' +\
2086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2088            'healthy: ' + repr(self.healthy) + ' ' +\
2089            'id: ' + repr(self.id) + ' ' +\
2090            'name: ' + repr(self.name) + ' ' +\
2091            'output: ' + repr(self.output) + ' ' +\
2092            'port_override: ' + repr(self.port_override) + ' ' +\
2093            'region: ' + repr(self.region) + ' ' +\
2094            'role_arn: ' + repr(self.role_arn) + ' ' +\
2095            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2096            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2098            'tags: ' + repr(self.tags) + ' ' +\
2099            '>'
2100
2101    def to_dict(self):
2102        return {
2103            'access_key': self.access_key,
2104            'bind_interface': self.bind_interface,
2105            'egress_filter': self.egress_filter,
2106            'healthy': self.healthy,
2107            'id': self.id,
2108            'name': self.name,
2109            'output': self.output,
2110            'port_override': self.port_override,
2111            'region': self.region,
2112            'role_arn': self.role_arn,
2113            'role_external_id': self.role_external_id,
2114            'secret_access_key': self.secret_access_key,
2115            'secret_store_id': self.secret_store_id,
2116            'tags': self.tags,
2117        }
2118
2119    @classmethod
2120    def from_dict(cls, d):
2121        return cls(
2122            access_key=d.get('access_key'),
2123            bind_interface=d.get('bind_interface'),
2124            egress_filter=d.get('egress_filter'),
2125            healthy=d.get('healthy'),
2126            id=d.get('id'),
2127            name=d.get('name'),
2128            output=d.get('output'),
2129            port_override=d.get('port_override'),
2130            region=d.get('region'),
2131            role_arn=d.get('role_arn'),
2132            role_external_id=d.get('role_external_id'),
2133            secret_access_key=d.get('secret_access_key'),
2134            secret_store_id=d.get('secret_store_id'),
2135            tags=d.get('tags'),
2136        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2030    def __init__(
2031        self,
2032        access_key=None,
2033        bind_interface=None,
2034        egress_filter=None,
2035        healthy=None,
2036        id=None,
2037        name=None,
2038        output=None,
2039        port_override=None,
2040        region=None,
2041        role_arn=None,
2042        role_external_id=None,
2043        secret_access_key=None,
2044        secret_store_id=None,
2045        tags=None,
2046    ):
2047        self.access_key = access_key if access_key is not None else ''
2048        self.bind_interface = bind_interface if bind_interface is not None else ''
2049        '''
2050         Bind interface
2051        '''
2052        self.egress_filter = egress_filter if egress_filter is not None else ''
2053        '''
2054         A filter applied to the routing logic to pin datasource to nodes.
2055        '''
2056        self.healthy = healthy if healthy is not None else False
2057        '''
2058         True if the datasource is reachable and the credentials are valid.
2059        '''
2060        self.id = id if id is not None else ''
2061        '''
2062         Unique identifier of the Resource.
2063        '''
2064        self.name = name if name is not None else ''
2065        '''
2066         Unique human-readable name of the Resource.
2067        '''
2068        self.output = output if output is not None else ''
2069        self.port_override = port_override if port_override is not None else 0
2070        self.region = region if region is not None else ''
2071        self.role_arn = role_arn if role_arn is not None else ''
2072        self.role_external_id = role_external_id if role_external_id is not None else ''
2073        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2075        '''
2076         ID of the secret store containing credentials for this resource, if any.
2077        '''
2078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2079        '''
2080         Tags is a map of key, value pairs.
2081        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2101    def to_dict(self):
2102        return {
2103            'access_key': self.access_key,
2104            'bind_interface': self.bind_interface,
2105            'egress_filter': self.egress_filter,
2106            'healthy': self.healthy,
2107            'id': self.id,
2108            'name': self.name,
2109            'output': self.output,
2110            'port_override': self.port_override,
2111            'region': self.region,
2112            'role_arn': self.role_arn,
2113            'role_external_id': self.role_external_id,
2114            'secret_access_key': self.secret_access_key,
2115            'secret_store_id': self.secret_store_id,
2116            'tags': self.tags,
2117        }
@classmethod
def from_dict(cls, d)
2119    @classmethod
2120    def from_dict(cls, d):
2121        return cls(
2122            access_key=d.get('access_key'),
2123            bind_interface=d.get('bind_interface'),
2124            egress_filter=d.get('egress_filter'),
2125            healthy=d.get('healthy'),
2126            id=d.get('id'),
2127            name=d.get('name'),
2128            output=d.get('output'),
2129            port_override=d.get('port_override'),
2130            region=d.get('region'),
2131            role_arn=d.get('role_arn'),
2132            role_external_id=d.get('role_external_id'),
2133            secret_access_key=d.get('secret_access_key'),
2134            secret_store_id=d.get('secret_store_id'),
2135            tags=d.get('tags'),
2136        )
class AuroraMysql:
2139class AuroraMysql:
2140    __slots__ = [
2141        'bind_interface',
2142        'database',
2143        'egress_filter',
2144        'healthy',
2145        'hostname',
2146        'id',
2147        'name',
2148        'password',
2149        'port',
2150        'port_override',
2151        'secret_store_id',
2152        'tags',
2153        'username',
2154    ]
2155
2156    def __init__(
2157        self,
2158        bind_interface=None,
2159        database=None,
2160        egress_filter=None,
2161        healthy=None,
2162        hostname=None,
2163        id=None,
2164        name=None,
2165        password=None,
2166        port=None,
2167        port_override=None,
2168        secret_store_id=None,
2169        tags=None,
2170        username=None,
2171    ):
2172        self.bind_interface = bind_interface if bind_interface is not None else ''
2173        '''
2174         Bind interface
2175        '''
2176        self.database = database if database is not None else ''
2177        self.egress_filter = egress_filter if egress_filter is not None else ''
2178        '''
2179         A filter applied to the routing logic to pin datasource to nodes.
2180        '''
2181        self.healthy = healthy if healthy is not None else False
2182        '''
2183         True if the datasource is reachable and the credentials are valid.
2184        '''
2185        self.hostname = hostname if hostname is not None else ''
2186        self.id = id if id is not None else ''
2187        '''
2188         Unique identifier of the Resource.
2189        '''
2190        self.name = name if name is not None else ''
2191        '''
2192         Unique human-readable name of the Resource.
2193        '''
2194        self.password = password if password is not None else ''
2195        self.port = port if port is not None else 0
2196        self.port_override = port_override if port_override is not None else 0
2197        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2198        '''
2199         ID of the secret store containing credentials for this resource, if any.
2200        '''
2201        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2202        '''
2203         Tags is a map of key, value pairs.
2204        '''
2205        self.username = username if username is not None else ''
2206
2207    def __repr__(self):
2208        return '<sdm.AuroraMysql ' + \
2209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2210            'database: ' + repr(self.database) + ' ' +\
2211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2212            'healthy: ' + repr(self.healthy) + ' ' +\
2213            'hostname: ' + repr(self.hostname) + ' ' +\
2214            'id: ' + repr(self.id) + ' ' +\
2215            'name: ' + repr(self.name) + ' ' +\
2216            'password: ' + repr(self.password) + ' ' +\
2217            'port: ' + repr(self.port) + ' ' +\
2218            'port_override: ' + repr(self.port_override) + ' ' +\
2219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2220            'tags: ' + repr(self.tags) + ' ' +\
2221            'username: ' + repr(self.username) + ' ' +\
2222            '>'
2223
2224    def to_dict(self):
2225        return {
2226            'bind_interface': self.bind_interface,
2227            'database': self.database,
2228            'egress_filter': self.egress_filter,
2229            'healthy': self.healthy,
2230            'hostname': self.hostname,
2231            'id': self.id,
2232            'name': self.name,
2233            'password': self.password,
2234            'port': self.port,
2235            'port_override': self.port_override,
2236            'secret_store_id': self.secret_store_id,
2237            'tags': self.tags,
2238            'username': self.username,
2239        }
2240
2241    @classmethod
2242    def from_dict(cls, d):
2243        return cls(
2244            bind_interface=d.get('bind_interface'),
2245            database=d.get('database'),
2246            egress_filter=d.get('egress_filter'),
2247            healthy=d.get('healthy'),
2248            hostname=d.get('hostname'),
2249            id=d.get('id'),
2250            name=d.get('name'),
2251            password=d.get('password'),
2252            port=d.get('port'),
2253            port_override=d.get('port_override'),
2254            secret_store_id=d.get('secret_store_id'),
2255            tags=d.get('tags'),
2256            username=d.get('username'),
2257        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2156    def __init__(
2157        self,
2158        bind_interface=None,
2159        database=None,
2160        egress_filter=None,
2161        healthy=None,
2162        hostname=None,
2163        id=None,
2164        name=None,
2165        password=None,
2166        port=None,
2167        port_override=None,
2168        secret_store_id=None,
2169        tags=None,
2170        username=None,
2171    ):
2172        self.bind_interface = bind_interface if bind_interface is not None else ''
2173        '''
2174         Bind interface
2175        '''
2176        self.database = database if database is not None else ''
2177        self.egress_filter = egress_filter if egress_filter is not None else ''
2178        '''
2179         A filter applied to the routing logic to pin datasource to nodes.
2180        '''
2181        self.healthy = healthy if healthy is not None else False
2182        '''
2183         True if the datasource is reachable and the credentials are valid.
2184        '''
2185        self.hostname = hostname if hostname is not None else ''
2186        self.id = id if id is not None else ''
2187        '''
2188         Unique identifier of the Resource.
2189        '''
2190        self.name = name if name is not None else ''
2191        '''
2192         Unique human-readable name of the Resource.
2193        '''
2194        self.password = password if password is not None else ''
2195        self.port = port if port is not None else 0
2196        self.port_override = port_override if port_override is not None else 0
2197        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2198        '''
2199         ID of the secret store containing credentials for this resource, if any.
2200        '''
2201        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2202        '''
2203         Tags is a map of key, value pairs.
2204        '''
2205        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2224    def to_dict(self):
2225        return {
2226            'bind_interface': self.bind_interface,
2227            'database': self.database,
2228            'egress_filter': self.egress_filter,
2229            'healthy': self.healthy,
2230            'hostname': self.hostname,
2231            'id': self.id,
2232            'name': self.name,
2233            'password': self.password,
2234            'port': self.port,
2235            'port_override': self.port_override,
2236            'secret_store_id': self.secret_store_id,
2237            'tags': self.tags,
2238            'username': self.username,
2239        }
@classmethod
def from_dict(cls, d)
2241    @classmethod
2242    def from_dict(cls, d):
2243        return cls(
2244            bind_interface=d.get('bind_interface'),
2245            database=d.get('database'),
2246            egress_filter=d.get('egress_filter'),
2247            healthy=d.get('healthy'),
2248            hostname=d.get('hostname'),
2249            id=d.get('id'),
2250            name=d.get('name'),
2251            password=d.get('password'),
2252            port=d.get('port'),
2253            port_override=d.get('port_override'),
2254            secret_store_id=d.get('secret_store_id'),
2255            tags=d.get('tags'),
2256            username=d.get('username'),
2257        )
class AuroraPostgres:
2260class AuroraPostgres:
2261    __slots__ = [
2262        'bind_interface',
2263        'database',
2264        'egress_filter',
2265        'healthy',
2266        'hostname',
2267        'id',
2268        'name',
2269        'override_database',
2270        'password',
2271        'port',
2272        'port_override',
2273        'secret_store_id',
2274        'tags',
2275        'username',
2276    ]
2277
2278    def __init__(
2279        self,
2280        bind_interface=None,
2281        database=None,
2282        egress_filter=None,
2283        healthy=None,
2284        hostname=None,
2285        id=None,
2286        name=None,
2287        override_database=None,
2288        password=None,
2289        port=None,
2290        port_override=None,
2291        secret_store_id=None,
2292        tags=None,
2293        username=None,
2294    ):
2295        self.bind_interface = bind_interface if bind_interface is not None else ''
2296        '''
2297         Bind interface
2298        '''
2299        self.database = database if database is not None else ''
2300        self.egress_filter = egress_filter if egress_filter is not None else ''
2301        '''
2302         A filter applied to the routing logic to pin datasource to nodes.
2303        '''
2304        self.healthy = healthy if healthy is not None else False
2305        '''
2306         True if the datasource is reachable and the credentials are valid.
2307        '''
2308        self.hostname = hostname if hostname is not None else ''
2309        self.id = id if id is not None else ''
2310        '''
2311         Unique identifier of the Resource.
2312        '''
2313        self.name = name if name is not None else ''
2314        '''
2315         Unique human-readable name of the Resource.
2316        '''
2317        self.override_database = override_database if override_database is not None else False
2318        self.password = password if password is not None else ''
2319        self.port = port if port is not None else 0
2320        self.port_override = port_override if port_override is not None else 0
2321        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2322        '''
2323         ID of the secret store containing credentials for this resource, if any.
2324        '''
2325        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2326        '''
2327         Tags is a map of key, value pairs.
2328        '''
2329        self.username = username if username is not None else ''
2330
2331    def __repr__(self):
2332        return '<sdm.AuroraPostgres ' + \
2333            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2334            'database: ' + repr(self.database) + ' ' +\
2335            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2336            'healthy: ' + repr(self.healthy) + ' ' +\
2337            'hostname: ' + repr(self.hostname) + ' ' +\
2338            'id: ' + repr(self.id) + ' ' +\
2339            'name: ' + repr(self.name) + ' ' +\
2340            'override_database: ' + repr(self.override_database) + ' ' +\
2341            'password: ' + repr(self.password) + ' ' +\
2342            'port: ' + repr(self.port) + ' ' +\
2343            'port_override: ' + repr(self.port_override) + ' ' +\
2344            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2345            'tags: ' + repr(self.tags) + ' ' +\
2346            'username: ' + repr(self.username) + ' ' +\
2347            '>'
2348
2349    def to_dict(self):
2350        return {
2351            'bind_interface': self.bind_interface,
2352            'database': self.database,
2353            'egress_filter': self.egress_filter,
2354            'healthy': self.healthy,
2355            'hostname': self.hostname,
2356            'id': self.id,
2357            'name': self.name,
2358            'override_database': self.override_database,
2359            'password': self.password,
2360            'port': self.port,
2361            'port_override': self.port_override,
2362            'secret_store_id': self.secret_store_id,
2363            'tags': self.tags,
2364            'username': self.username,
2365        }
2366
2367    @classmethod
2368    def from_dict(cls, d):
2369        return cls(
2370            bind_interface=d.get('bind_interface'),
2371            database=d.get('database'),
2372            egress_filter=d.get('egress_filter'),
2373            healthy=d.get('healthy'),
2374            hostname=d.get('hostname'),
2375            id=d.get('id'),
2376            name=d.get('name'),
2377            override_database=d.get('override_database'),
2378            password=d.get('password'),
2379            port=d.get('port'),
2380            port_override=d.get('port_override'),
2381            secret_store_id=d.get('secret_store_id'),
2382            tags=d.get('tags'),
2383            username=d.get('username'),
2384        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2278    def __init__(
2279        self,
2280        bind_interface=None,
2281        database=None,
2282        egress_filter=None,
2283        healthy=None,
2284        hostname=None,
2285        id=None,
2286        name=None,
2287        override_database=None,
2288        password=None,
2289        port=None,
2290        port_override=None,
2291        secret_store_id=None,
2292        tags=None,
2293        username=None,
2294    ):
2295        self.bind_interface = bind_interface if bind_interface is not None else ''
2296        '''
2297         Bind interface
2298        '''
2299        self.database = database if database is not None else ''
2300        self.egress_filter = egress_filter if egress_filter is not None else ''
2301        '''
2302         A filter applied to the routing logic to pin datasource to nodes.
2303        '''
2304        self.healthy = healthy if healthy is not None else False
2305        '''
2306         True if the datasource is reachable and the credentials are valid.
2307        '''
2308        self.hostname = hostname if hostname is not None else ''
2309        self.id = id if id is not None else ''
2310        '''
2311         Unique identifier of the Resource.
2312        '''
2313        self.name = name if name is not None else ''
2314        '''
2315         Unique human-readable name of the Resource.
2316        '''
2317        self.override_database = override_database if override_database is not None else False
2318        self.password = password if password is not None else ''
2319        self.port = port if port is not None else 0
2320        self.port_override = port_override if port_override is not None else 0
2321        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2322        '''
2323         ID of the secret store containing credentials for this resource, if any.
2324        '''
2325        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2326        '''
2327         Tags is a map of key, value pairs.
2328        '''
2329        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2349    def to_dict(self):
2350        return {
2351            'bind_interface': self.bind_interface,
2352            'database': self.database,
2353            'egress_filter': self.egress_filter,
2354            'healthy': self.healthy,
2355            'hostname': self.hostname,
2356            'id': self.id,
2357            'name': self.name,
2358            'override_database': self.override_database,
2359            'password': self.password,
2360            'port': self.port,
2361            'port_override': self.port_override,
2362            'secret_store_id': self.secret_store_id,
2363            'tags': self.tags,
2364            'username': self.username,
2365        }
@classmethod
def from_dict(cls, d)
2367    @classmethod
2368    def from_dict(cls, d):
2369        return cls(
2370            bind_interface=d.get('bind_interface'),
2371            database=d.get('database'),
2372            egress_filter=d.get('egress_filter'),
2373            healthy=d.get('healthy'),
2374            hostname=d.get('hostname'),
2375            id=d.get('id'),
2376            name=d.get('name'),
2377            override_database=d.get('override_database'),
2378            password=d.get('password'),
2379            port=d.get('port'),
2380            port_override=d.get('port_override'),
2381            secret_store_id=d.get('secret_store_id'),
2382            tags=d.get('tags'),
2383            username=d.get('username'),
2384        )
class Azure:
2387class Azure:
2388    __slots__ = [
2389        'app_id',
2390        'bind_interface',
2391        'egress_filter',
2392        'healthy',
2393        'id',
2394        'name',
2395        'password',
2396        'secret_store_id',
2397        'tags',
2398        'tenant_id',
2399    ]
2400
2401    def __init__(
2402        self,
2403        app_id=None,
2404        bind_interface=None,
2405        egress_filter=None,
2406        healthy=None,
2407        id=None,
2408        name=None,
2409        password=None,
2410        secret_store_id=None,
2411        tags=None,
2412        tenant_id=None,
2413    ):
2414        self.app_id = app_id if app_id is not None else ''
2415        self.bind_interface = bind_interface if bind_interface is not None else ''
2416        '''
2417         Bind interface
2418        '''
2419        self.egress_filter = egress_filter if egress_filter is not None else ''
2420        '''
2421         A filter applied to the routing logic to pin datasource to nodes.
2422        '''
2423        self.healthy = healthy if healthy is not None else False
2424        '''
2425         True if the datasource is reachable and the credentials are valid.
2426        '''
2427        self.id = id if id is not None else ''
2428        '''
2429         Unique identifier of the Resource.
2430        '''
2431        self.name = name if name is not None else ''
2432        '''
2433         Unique human-readable name of the Resource.
2434        '''
2435        self.password = password if password is not None else ''
2436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2437        '''
2438         ID of the secret store containing credentials for this resource, if any.
2439        '''
2440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2441        '''
2442         Tags is a map of key, value pairs.
2443        '''
2444        self.tenant_id = tenant_id if tenant_id is not None else ''
2445
2446    def __repr__(self):
2447        return '<sdm.Azure ' + \
2448            'app_id: ' + repr(self.app_id) + ' ' +\
2449            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2450            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2451            'healthy: ' + repr(self.healthy) + ' ' +\
2452            'id: ' + repr(self.id) + ' ' +\
2453            'name: ' + repr(self.name) + ' ' +\
2454            'password: ' + repr(self.password) + ' ' +\
2455            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2456            'tags: ' + repr(self.tags) + ' ' +\
2457            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2458            '>'
2459
2460    def to_dict(self):
2461        return {
2462            'app_id': self.app_id,
2463            'bind_interface': self.bind_interface,
2464            'egress_filter': self.egress_filter,
2465            'healthy': self.healthy,
2466            'id': self.id,
2467            'name': self.name,
2468            'password': self.password,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'tenant_id': self.tenant_id,
2472        }
2473
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            app_id=d.get('app_id'),
2478            bind_interface=d.get('bind_interface'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            id=d.get('id'),
2482            name=d.get('name'),
2483            password=d.get('password'),
2484            secret_store_id=d.get('secret_store_id'),
2485            tags=d.get('tags'),
2486            tenant_id=d.get('tenant_id'),
2487        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2401    def __init__(
2402        self,
2403        app_id=None,
2404        bind_interface=None,
2405        egress_filter=None,
2406        healthy=None,
2407        id=None,
2408        name=None,
2409        password=None,
2410        secret_store_id=None,
2411        tags=None,
2412        tenant_id=None,
2413    ):
2414        self.app_id = app_id if app_id is not None else ''
2415        self.bind_interface = bind_interface if bind_interface is not None else ''
2416        '''
2417         Bind interface
2418        '''
2419        self.egress_filter = egress_filter if egress_filter is not None else ''
2420        '''
2421         A filter applied to the routing logic to pin datasource to nodes.
2422        '''
2423        self.healthy = healthy if healthy is not None else False
2424        '''
2425         True if the datasource is reachable and the credentials are valid.
2426        '''
2427        self.id = id if id is not None else ''
2428        '''
2429         Unique identifier of the Resource.
2430        '''
2431        self.name = name if name is not None else ''
2432        '''
2433         Unique human-readable name of the Resource.
2434        '''
2435        self.password = password if password is not None else ''
2436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2437        '''
2438         ID of the secret store containing credentials for this resource, if any.
2439        '''
2440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2441        '''
2442         Tags is a map of key, value pairs.
2443        '''
2444        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2460    def to_dict(self):
2461        return {
2462            'app_id': self.app_id,
2463            'bind_interface': self.bind_interface,
2464            'egress_filter': self.egress_filter,
2465            'healthy': self.healthy,
2466            'id': self.id,
2467            'name': self.name,
2468            'password': self.password,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'tenant_id': self.tenant_id,
2472        }
@classmethod
def from_dict(cls, d)
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            app_id=d.get('app_id'),
2478            bind_interface=d.get('bind_interface'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            id=d.get('id'),
2482            name=d.get('name'),
2483            password=d.get('password'),
2484            secret_store_id=d.get('secret_store_id'),
2485            tags=d.get('tags'),
2486            tenant_id=d.get('tenant_id'),
2487        )
class AzureCertificate:
2490class AzureCertificate:
2491    __slots__ = [
2492        'app_id',
2493        'bind_interface',
2494        'client_certificate',
2495        'egress_filter',
2496        'healthy',
2497        'id',
2498        'name',
2499        'secret_store_id',
2500        'tags',
2501        'tenant_id',
2502    ]
2503
2504    def __init__(
2505        self,
2506        app_id=None,
2507        bind_interface=None,
2508        client_certificate=None,
2509        egress_filter=None,
2510        healthy=None,
2511        id=None,
2512        name=None,
2513        secret_store_id=None,
2514        tags=None,
2515        tenant_id=None,
2516    ):
2517        self.app_id = app_id if app_id is not None else ''
2518        self.bind_interface = bind_interface if bind_interface is not None else ''
2519        '''
2520         Bind interface
2521        '''
2522        self.client_certificate = client_certificate if client_certificate is not None else ''
2523        self.egress_filter = egress_filter if egress_filter is not None else ''
2524        '''
2525         A filter applied to the routing logic to pin datasource to nodes.
2526        '''
2527        self.healthy = healthy if healthy is not None else False
2528        '''
2529         True if the datasource is reachable and the credentials are valid.
2530        '''
2531        self.id = id if id is not None else ''
2532        '''
2533         Unique identifier of the Resource.
2534        '''
2535        self.name = name if name is not None else ''
2536        '''
2537         Unique human-readable name of the Resource.
2538        '''
2539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2540        '''
2541         ID of the secret store containing credentials for this resource, if any.
2542        '''
2543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2544        '''
2545         Tags is a map of key, value pairs.
2546        '''
2547        self.tenant_id = tenant_id if tenant_id is not None else ''
2548
2549    def __repr__(self):
2550        return '<sdm.AzureCertificate ' + \
2551            'app_id: ' + repr(self.app_id) + ' ' +\
2552            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2553            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2554            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2555            'healthy: ' + repr(self.healthy) + ' ' +\
2556            'id: ' + repr(self.id) + ' ' +\
2557            'name: ' + repr(self.name) + ' ' +\
2558            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2559            'tags: ' + repr(self.tags) + ' ' +\
2560            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2561            '>'
2562
2563    def to_dict(self):
2564        return {
2565            'app_id': self.app_id,
2566            'bind_interface': self.bind_interface,
2567            'client_certificate': self.client_certificate,
2568            'egress_filter': self.egress_filter,
2569            'healthy': self.healthy,
2570            'id': self.id,
2571            'name': self.name,
2572            'secret_store_id': self.secret_store_id,
2573            'tags': self.tags,
2574            'tenant_id': self.tenant_id,
2575        }
2576
2577    @classmethod
2578    def from_dict(cls, d):
2579        return cls(
2580            app_id=d.get('app_id'),
2581            bind_interface=d.get('bind_interface'),
2582            client_certificate=d.get('client_certificate'),
2583            egress_filter=d.get('egress_filter'),
2584            healthy=d.get('healthy'),
2585            id=d.get('id'),
2586            name=d.get('name'),
2587            secret_store_id=d.get('secret_store_id'),
2588            tags=d.get('tags'),
2589            tenant_id=d.get('tenant_id'),
2590        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2504    def __init__(
2505        self,
2506        app_id=None,
2507        bind_interface=None,
2508        client_certificate=None,
2509        egress_filter=None,
2510        healthy=None,
2511        id=None,
2512        name=None,
2513        secret_store_id=None,
2514        tags=None,
2515        tenant_id=None,
2516    ):
2517        self.app_id = app_id if app_id is not None else ''
2518        self.bind_interface = bind_interface if bind_interface is not None else ''
2519        '''
2520         Bind interface
2521        '''
2522        self.client_certificate = client_certificate if client_certificate is not None else ''
2523        self.egress_filter = egress_filter if egress_filter is not None else ''
2524        '''
2525         A filter applied to the routing logic to pin datasource to nodes.
2526        '''
2527        self.healthy = healthy if healthy is not None else False
2528        '''
2529         True if the datasource is reachable and the credentials are valid.
2530        '''
2531        self.id = id if id is not None else ''
2532        '''
2533         Unique identifier of the Resource.
2534        '''
2535        self.name = name if name is not None else ''
2536        '''
2537         Unique human-readable name of the Resource.
2538        '''
2539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2540        '''
2541         ID of the secret store containing credentials for this resource, if any.
2542        '''
2543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2544        '''
2545         Tags is a map of key, value pairs.
2546        '''
2547        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2563    def to_dict(self):
2564        return {
2565            'app_id': self.app_id,
2566            'bind_interface': self.bind_interface,
2567            'client_certificate': self.client_certificate,
2568            'egress_filter': self.egress_filter,
2569            'healthy': self.healthy,
2570            'id': self.id,
2571            'name': self.name,
2572            'secret_store_id': self.secret_store_id,
2573            'tags': self.tags,
2574            'tenant_id': self.tenant_id,
2575        }
@classmethod
def from_dict(cls, d)
2577    @classmethod
2578    def from_dict(cls, d):
2579        return cls(
2580            app_id=d.get('app_id'),
2581            bind_interface=d.get('bind_interface'),
2582            client_certificate=d.get('client_certificate'),
2583            egress_filter=d.get('egress_filter'),
2584            healthy=d.get('healthy'),
2585            id=d.get('id'),
2586            name=d.get('name'),
2587            secret_store_id=d.get('secret_store_id'),
2588            tags=d.get('tags'),
2589            tenant_id=d.get('tenant_id'),
2590        )
class AzurePostgres:
2593class AzurePostgres:
2594    __slots__ = [
2595        'bind_interface',
2596        'database',
2597        'egress_filter',
2598        'healthy',
2599        'hostname',
2600        'id',
2601        'name',
2602        'override_database',
2603        'password',
2604        'port',
2605        'port_override',
2606        'secret_store_id',
2607        'tags',
2608        'username',
2609    ]
2610
2611    def __init__(
2612        self,
2613        bind_interface=None,
2614        database=None,
2615        egress_filter=None,
2616        healthy=None,
2617        hostname=None,
2618        id=None,
2619        name=None,
2620        override_database=None,
2621        password=None,
2622        port=None,
2623        port_override=None,
2624        secret_store_id=None,
2625        tags=None,
2626        username=None,
2627    ):
2628        self.bind_interface = bind_interface if bind_interface is not None else ''
2629        '''
2630         Bind interface
2631        '''
2632        self.database = database if database is not None else ''
2633        self.egress_filter = egress_filter if egress_filter is not None else ''
2634        '''
2635         A filter applied to the routing logic to pin datasource to nodes.
2636        '''
2637        self.healthy = healthy if healthy is not None else False
2638        '''
2639         True if the datasource is reachable and the credentials are valid.
2640        '''
2641        self.hostname = hostname if hostname is not None else ''
2642        self.id = id if id is not None else ''
2643        '''
2644         Unique identifier of the Resource.
2645        '''
2646        self.name = name if name is not None else ''
2647        '''
2648         Unique human-readable name of the Resource.
2649        '''
2650        self.override_database = override_database if override_database is not None else False
2651        self.password = password if password is not None else ''
2652        self.port = port if port is not None else 0
2653        self.port_override = port_override if port_override is not None else 0
2654        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2655        '''
2656         ID of the secret store containing credentials for this resource, if any.
2657        '''
2658        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2659        '''
2660         Tags is a map of key, value pairs.
2661        '''
2662        self.username = username if username is not None else ''
2663
2664    def __repr__(self):
2665        return '<sdm.AzurePostgres ' + \
2666            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2667            'database: ' + repr(self.database) + ' ' +\
2668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2669            'healthy: ' + repr(self.healthy) + ' ' +\
2670            'hostname: ' + repr(self.hostname) + ' ' +\
2671            'id: ' + repr(self.id) + ' ' +\
2672            'name: ' + repr(self.name) + ' ' +\
2673            'override_database: ' + repr(self.override_database) + ' ' +\
2674            'password: ' + repr(self.password) + ' ' +\
2675            'port: ' + repr(self.port) + ' ' +\
2676            'port_override: ' + repr(self.port_override) + ' ' +\
2677            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2678            'tags: ' + repr(self.tags) + ' ' +\
2679            'username: ' + repr(self.username) + ' ' +\
2680            '>'
2681
2682    def to_dict(self):
2683        return {
2684            'bind_interface': self.bind_interface,
2685            'database': self.database,
2686            'egress_filter': self.egress_filter,
2687            'healthy': self.healthy,
2688            'hostname': self.hostname,
2689            'id': self.id,
2690            'name': self.name,
2691            'override_database': self.override_database,
2692            'password': self.password,
2693            'port': self.port,
2694            'port_override': self.port_override,
2695            'secret_store_id': self.secret_store_id,
2696            'tags': self.tags,
2697            'username': self.username,
2698        }
2699
2700    @classmethod
2701    def from_dict(cls, d):
2702        return cls(
2703            bind_interface=d.get('bind_interface'),
2704            database=d.get('database'),
2705            egress_filter=d.get('egress_filter'),
2706            healthy=d.get('healthy'),
2707            hostname=d.get('hostname'),
2708            id=d.get('id'),
2709            name=d.get('name'),
2710            override_database=d.get('override_database'),
2711            password=d.get('password'),
2712            port=d.get('port'),
2713            port_override=d.get('port_override'),
2714            secret_store_id=d.get('secret_store_id'),
2715            tags=d.get('tags'),
2716            username=d.get('username'),
2717        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2611    def __init__(
2612        self,
2613        bind_interface=None,
2614        database=None,
2615        egress_filter=None,
2616        healthy=None,
2617        hostname=None,
2618        id=None,
2619        name=None,
2620        override_database=None,
2621        password=None,
2622        port=None,
2623        port_override=None,
2624        secret_store_id=None,
2625        tags=None,
2626        username=None,
2627    ):
2628        self.bind_interface = bind_interface if bind_interface is not None else ''
2629        '''
2630         Bind interface
2631        '''
2632        self.database = database if database is not None else ''
2633        self.egress_filter = egress_filter if egress_filter is not None else ''
2634        '''
2635         A filter applied to the routing logic to pin datasource to nodes.
2636        '''
2637        self.healthy = healthy if healthy is not None else False
2638        '''
2639         True if the datasource is reachable and the credentials are valid.
2640        '''
2641        self.hostname = hostname if hostname is not None else ''
2642        self.id = id if id is not None else ''
2643        '''
2644         Unique identifier of the Resource.
2645        '''
2646        self.name = name if name is not None else ''
2647        '''
2648         Unique human-readable name of the Resource.
2649        '''
2650        self.override_database = override_database if override_database is not None else False
2651        self.password = password if password is not None else ''
2652        self.port = port if port is not None else 0
2653        self.port_override = port_override if port_override is not None else 0
2654        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2655        '''
2656         ID of the secret store containing credentials for this resource, if any.
2657        '''
2658        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2659        '''
2660         Tags is a map of key, value pairs.
2661        '''
2662        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2682    def to_dict(self):
2683        return {
2684            'bind_interface': self.bind_interface,
2685            'database': self.database,
2686            'egress_filter': self.egress_filter,
2687            'healthy': self.healthy,
2688            'hostname': self.hostname,
2689            'id': self.id,
2690            'name': self.name,
2691            'override_database': self.override_database,
2692            'password': self.password,
2693            'port': self.port,
2694            'port_override': self.port_override,
2695            'secret_store_id': self.secret_store_id,
2696            'tags': self.tags,
2697            'username': self.username,
2698        }
@classmethod
def from_dict(cls, d)
2700    @classmethod
2701    def from_dict(cls, d):
2702        return cls(
2703            bind_interface=d.get('bind_interface'),
2704            database=d.get('database'),
2705            egress_filter=d.get('egress_filter'),
2706            healthy=d.get('healthy'),
2707            hostname=d.get('hostname'),
2708            id=d.get('id'),
2709            name=d.get('name'),
2710            override_database=d.get('override_database'),
2711            password=d.get('password'),
2712            port=d.get('port'),
2713            port_override=d.get('port_override'),
2714            secret_store_id=d.get('secret_store_id'),
2715            tags=d.get('tags'),
2716            username=d.get('username'),
2717        )
class AzureStore:
2720class AzureStore:
2721    __slots__ = [
2722        'id',
2723        'name',
2724        'tags',
2725        'vault_uri',
2726    ]
2727
2728    def __init__(
2729        self,
2730        id=None,
2731        name=None,
2732        tags=None,
2733        vault_uri=None,
2734    ):
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the SecretStore.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the SecretStore.
2742        '''
2743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2744        '''
2745         Tags is a map of key, value pairs.
2746        '''
2747        self.vault_uri = vault_uri if vault_uri is not None else ''
2748
2749    def __repr__(self):
2750        return '<sdm.AzureStore ' + \
2751            'id: ' + repr(self.id) + ' ' +\
2752            'name: ' + repr(self.name) + ' ' +\
2753            'tags: ' + repr(self.tags) + ' ' +\
2754            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
2755            '>'
2756
2757    def to_dict(self):
2758        return {
2759            'id': self.id,
2760            'name': self.name,
2761            'tags': self.tags,
2762            'vault_uri': self.vault_uri,
2763        }
2764
2765    @classmethod
2766    def from_dict(cls, d):
2767        return cls(
2768            id=d.get('id'),
2769            name=d.get('name'),
2770            tags=d.get('tags'),
2771            vault_uri=d.get('vault_uri'),
2772        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
2728    def __init__(
2729        self,
2730        id=None,
2731        name=None,
2732        tags=None,
2733        vault_uri=None,
2734    ):
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the SecretStore.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the SecretStore.
2742        '''
2743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2744        '''
2745         Tags is a map of key, value pairs.
2746        '''
2747        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
2757    def to_dict(self):
2758        return {
2759            'id': self.id,
2760            'name': self.name,
2761            'tags': self.tags,
2762            'vault_uri': self.vault_uri,
2763        }
@classmethod
def from_dict(cls, d)
2765    @classmethod
2766    def from_dict(cls, d):
2767        return cls(
2768            id=d.get('id'),
2769            name=d.get('name'),
2770            tags=d.get('tags'),
2771            vault_uri=d.get('vault_uri'),
2772        )
class BigQuery:
2775class BigQuery:
2776    __slots__ = [
2777        'bind_interface',
2778        'egress_filter',
2779        'endpoint',
2780        'healthy',
2781        'id',
2782        'name',
2783        'port_override',
2784        'private_key',
2785        'project',
2786        'secret_store_id',
2787        'tags',
2788        'username',
2789    ]
2790
2791    def __init__(
2792        self,
2793        bind_interface=None,
2794        egress_filter=None,
2795        endpoint=None,
2796        healthy=None,
2797        id=None,
2798        name=None,
2799        port_override=None,
2800        private_key=None,
2801        project=None,
2802        secret_store_id=None,
2803        tags=None,
2804        username=None,
2805    ):
2806        self.bind_interface = bind_interface if bind_interface is not None else ''
2807        '''
2808         Bind interface
2809        '''
2810        self.egress_filter = egress_filter if egress_filter is not None else ''
2811        '''
2812         A filter applied to the routing logic to pin datasource to nodes.
2813        '''
2814        self.endpoint = endpoint if endpoint is not None else ''
2815        self.healthy = healthy if healthy is not None else False
2816        '''
2817         True if the datasource is reachable and the credentials are valid.
2818        '''
2819        self.id = id if id is not None else ''
2820        '''
2821         Unique identifier of the Resource.
2822        '''
2823        self.name = name if name is not None else ''
2824        '''
2825         Unique human-readable name of the Resource.
2826        '''
2827        self.port_override = port_override if port_override is not None else 0
2828        self.private_key = private_key if private_key is not None else ''
2829        self.project = project if project is not None else ''
2830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2831        '''
2832         ID of the secret store containing credentials for this resource, if any.
2833        '''
2834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2835        '''
2836         Tags is a map of key, value pairs.
2837        '''
2838        self.username = username if username is not None else ''
2839
2840    def __repr__(self):
2841        return '<sdm.BigQuery ' + \
2842            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2843            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2844            'endpoint: ' + repr(self.endpoint) + ' ' +\
2845            'healthy: ' + repr(self.healthy) + ' ' +\
2846            'id: ' + repr(self.id) + ' ' +\
2847            'name: ' + repr(self.name) + ' ' +\
2848            'port_override: ' + repr(self.port_override) + ' ' +\
2849            'private_key: ' + repr(self.private_key) + ' ' +\
2850            'project: ' + repr(self.project) + ' ' +\
2851            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2852            'tags: ' + repr(self.tags) + ' ' +\
2853            'username: ' + repr(self.username) + ' ' +\
2854            '>'
2855
2856    def to_dict(self):
2857        return {
2858            'bind_interface': self.bind_interface,
2859            'egress_filter': self.egress_filter,
2860            'endpoint': self.endpoint,
2861            'healthy': self.healthy,
2862            'id': self.id,
2863            'name': self.name,
2864            'port_override': self.port_override,
2865            'private_key': self.private_key,
2866            'project': self.project,
2867            'secret_store_id': self.secret_store_id,
2868            'tags': self.tags,
2869            'username': self.username,
2870        }
2871
2872    @classmethod
2873    def from_dict(cls, d):
2874        return cls(
2875            bind_interface=d.get('bind_interface'),
2876            egress_filter=d.get('egress_filter'),
2877            endpoint=d.get('endpoint'),
2878            healthy=d.get('healthy'),
2879            id=d.get('id'),
2880            name=d.get('name'),
2881            port_override=d.get('port_override'),
2882            private_key=d.get('private_key'),
2883            project=d.get('project'),
2884            secret_store_id=d.get('secret_store_id'),
2885            tags=d.get('tags'),
2886            username=d.get('username'),
2887        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
2791    def __init__(
2792        self,
2793        bind_interface=None,
2794        egress_filter=None,
2795        endpoint=None,
2796        healthy=None,
2797        id=None,
2798        name=None,
2799        port_override=None,
2800        private_key=None,
2801        project=None,
2802        secret_store_id=None,
2803        tags=None,
2804        username=None,
2805    ):
2806        self.bind_interface = bind_interface if bind_interface is not None else ''
2807        '''
2808         Bind interface
2809        '''
2810        self.egress_filter = egress_filter if egress_filter is not None else ''
2811        '''
2812         A filter applied to the routing logic to pin datasource to nodes.
2813        '''
2814        self.endpoint = endpoint if endpoint is not None else ''
2815        self.healthy = healthy if healthy is not None else False
2816        '''
2817         True if the datasource is reachable and the credentials are valid.
2818        '''
2819        self.id = id if id is not None else ''
2820        '''
2821         Unique identifier of the Resource.
2822        '''
2823        self.name = name if name is not None else ''
2824        '''
2825         Unique human-readable name of the Resource.
2826        '''
2827        self.port_override = port_override if port_override is not None else 0
2828        self.private_key = private_key if private_key is not None else ''
2829        self.project = project if project is not None else ''
2830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2831        '''
2832         ID of the secret store containing credentials for this resource, if any.
2833        '''
2834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2835        '''
2836         Tags is a map of key, value pairs.
2837        '''
2838        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2856    def to_dict(self):
2857        return {
2858            'bind_interface': self.bind_interface,
2859            'egress_filter': self.egress_filter,
2860            'endpoint': self.endpoint,
2861            'healthy': self.healthy,
2862            'id': self.id,
2863            'name': self.name,
2864            'port_override': self.port_override,
2865            'private_key': self.private_key,
2866            'project': self.project,
2867            'secret_store_id': self.secret_store_id,
2868            'tags': self.tags,
2869            'username': self.username,
2870        }
@classmethod
def from_dict(cls, d)
2872    @classmethod
2873    def from_dict(cls, d):
2874        return cls(
2875            bind_interface=d.get('bind_interface'),
2876            egress_filter=d.get('egress_filter'),
2877            endpoint=d.get('endpoint'),
2878            healthy=d.get('healthy'),
2879            id=d.get('id'),
2880            name=d.get('name'),
2881            port_override=d.get('port_override'),
2882            private_key=d.get('private_key'),
2883            project=d.get('project'),
2884            secret_store_id=d.get('secret_store_id'),
2885            tags=d.get('tags'),
2886            username=d.get('username'),
2887        )
class Cassandra:
2890class Cassandra:
2891    __slots__ = [
2892        'bind_interface',
2893        'egress_filter',
2894        'healthy',
2895        'hostname',
2896        'id',
2897        'name',
2898        'password',
2899        'port',
2900        'port_override',
2901        'secret_store_id',
2902        'tags',
2903        'tls_required',
2904        'username',
2905    ]
2906
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        egress_filter=None,
2911        healthy=None,
2912        hostname=None,
2913        id=None,
2914        name=None,
2915        password=None,
2916        port=None,
2917        port_override=None,
2918        secret_store_id=None,
2919        tags=None,
2920        tls_required=None,
2921        username=None,
2922    ):
2923        self.bind_interface = bind_interface if bind_interface is not None else ''
2924        '''
2925         Bind interface
2926        '''
2927        self.egress_filter = egress_filter if egress_filter is not None else ''
2928        '''
2929         A filter applied to the routing logic to pin datasource to nodes.
2930        '''
2931        self.healthy = healthy if healthy is not None else False
2932        '''
2933         True if the datasource is reachable and the credentials are valid.
2934        '''
2935        self.hostname = hostname if hostname is not None else ''
2936        self.id = id if id is not None else ''
2937        '''
2938         Unique identifier of the Resource.
2939        '''
2940        self.name = name if name is not None else ''
2941        '''
2942         Unique human-readable name of the Resource.
2943        '''
2944        self.password = password if password is not None else ''
2945        self.port = port if port is not None else 0
2946        self.port_override = port_override if port_override is not None else 0
2947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2948        '''
2949         ID of the secret store containing credentials for this resource, if any.
2950        '''
2951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2952        '''
2953         Tags is a map of key, value pairs.
2954        '''
2955        self.tls_required = tls_required if tls_required is not None else False
2956        self.username = username if username is not None else ''
2957
2958    def __repr__(self):
2959        return '<sdm.Cassandra ' + \
2960            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2961            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2962            'healthy: ' + repr(self.healthy) + ' ' +\
2963            'hostname: ' + repr(self.hostname) + ' ' +\
2964            'id: ' + repr(self.id) + ' ' +\
2965            'name: ' + repr(self.name) + ' ' +\
2966            'password: ' + repr(self.password) + ' ' +\
2967            'port: ' + repr(self.port) + ' ' +\
2968            'port_override: ' + repr(self.port_override) + ' ' +\
2969            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2970            'tags: ' + repr(self.tags) + ' ' +\
2971            'tls_required: ' + repr(self.tls_required) + ' ' +\
2972            'username: ' + repr(self.username) + ' ' +\
2973            '>'
2974
2975    def to_dict(self):
2976        return {
2977            'bind_interface': self.bind_interface,
2978            'egress_filter': self.egress_filter,
2979            'healthy': self.healthy,
2980            'hostname': self.hostname,
2981            'id': self.id,
2982            'name': self.name,
2983            'password': self.password,
2984            'port': self.port,
2985            'port_override': self.port_override,
2986            'secret_store_id': self.secret_store_id,
2987            'tags': self.tags,
2988            'tls_required': self.tls_required,
2989            'username': self.username,
2990        }
2991
2992    @classmethod
2993    def from_dict(cls, d):
2994        return cls(
2995            bind_interface=d.get('bind_interface'),
2996            egress_filter=d.get('egress_filter'),
2997            healthy=d.get('healthy'),
2998            hostname=d.get('hostname'),
2999            id=d.get('id'),
3000            name=d.get('name'),
3001            password=d.get('password'),
3002            port=d.get('port'),
3003            port_override=d.get('port_override'),
3004            secret_store_id=d.get('secret_store_id'),
3005            tags=d.get('tags'),
3006            tls_required=d.get('tls_required'),
3007            username=d.get('username'),
3008        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        egress_filter=None,
2911        healthy=None,
2912        hostname=None,
2913        id=None,
2914        name=None,
2915        password=None,
2916        port=None,
2917        port_override=None,
2918        secret_store_id=None,
2919        tags=None,
2920        tls_required=None,
2921        username=None,
2922    ):
2923        self.bind_interface = bind_interface if bind_interface is not None else ''
2924        '''
2925         Bind interface
2926        '''
2927        self.egress_filter = egress_filter if egress_filter is not None else ''
2928        '''
2929         A filter applied to the routing logic to pin datasource to nodes.
2930        '''
2931        self.healthy = healthy if healthy is not None else False
2932        '''
2933         True if the datasource is reachable and the credentials are valid.
2934        '''
2935        self.hostname = hostname if hostname is not None else ''
2936        self.id = id if id is not None else ''
2937        '''
2938         Unique identifier of the Resource.
2939        '''
2940        self.name = name if name is not None else ''
2941        '''
2942         Unique human-readable name of the Resource.
2943        '''
2944        self.password = password if password is not None else ''
2945        self.port = port if port is not None else 0
2946        self.port_override = port_override if port_override is not None else 0
2947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2948        '''
2949         ID of the secret store containing credentials for this resource, if any.
2950        '''
2951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2952        '''
2953         Tags is a map of key, value pairs.
2954        '''
2955        self.tls_required = tls_required if tls_required is not None else False
2956        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2975    def to_dict(self):
2976        return {
2977            'bind_interface': self.bind_interface,
2978            'egress_filter': self.egress_filter,
2979            'healthy': self.healthy,
2980            'hostname': self.hostname,
2981            'id': self.id,
2982            'name': self.name,
2983            'password': self.password,
2984            'port': self.port,
2985            'port_override': self.port_override,
2986            'secret_store_id': self.secret_store_id,
2987            'tags': self.tags,
2988            'tls_required': self.tls_required,
2989            'username': self.username,
2990        }
@classmethod
def from_dict(cls, d)
2992    @classmethod
2993    def from_dict(cls, d):
2994        return cls(
2995            bind_interface=d.get('bind_interface'),
2996            egress_filter=d.get('egress_filter'),
2997            healthy=d.get('healthy'),
2998            hostname=d.get('hostname'),
2999            id=d.get('id'),
3000            name=d.get('name'),
3001            password=d.get('password'),
3002            port=d.get('port'),
3003            port_override=d.get('port_override'),
3004            secret_store_id=d.get('secret_store_id'),
3005            tags=d.get('tags'),
3006            tls_required=d.get('tls_required'),
3007            username=d.get('username'),
3008        )
class Citus:
3011class Citus:
3012    __slots__ = [
3013        'bind_interface',
3014        'database',
3015        'egress_filter',
3016        'healthy',
3017        'hostname',
3018        'id',
3019        'name',
3020        'override_database',
3021        'password',
3022        'port',
3023        'port_override',
3024        'secret_store_id',
3025        'tags',
3026        'username',
3027    ]
3028
3029    def __init__(
3030        self,
3031        bind_interface=None,
3032        database=None,
3033        egress_filter=None,
3034        healthy=None,
3035        hostname=None,
3036        id=None,
3037        name=None,
3038        override_database=None,
3039        password=None,
3040        port=None,
3041        port_override=None,
3042        secret_store_id=None,
3043        tags=None,
3044        username=None,
3045    ):
3046        self.bind_interface = bind_interface if bind_interface is not None else ''
3047        '''
3048         Bind interface
3049        '''
3050        self.database = database if database is not None else ''
3051        self.egress_filter = egress_filter if egress_filter is not None else ''
3052        '''
3053         A filter applied to the routing logic to pin datasource to nodes.
3054        '''
3055        self.healthy = healthy if healthy is not None else False
3056        '''
3057         True if the datasource is reachable and the credentials are valid.
3058        '''
3059        self.hostname = hostname if hostname is not None else ''
3060        self.id = id if id is not None else ''
3061        '''
3062         Unique identifier of the Resource.
3063        '''
3064        self.name = name if name is not None else ''
3065        '''
3066         Unique human-readable name of the Resource.
3067        '''
3068        self.override_database = override_database if override_database is not None else False
3069        self.password = password if password is not None else ''
3070        self.port = port if port is not None else 0
3071        self.port_override = port_override if port_override is not None else 0
3072        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3073        '''
3074         ID of the secret store containing credentials for this resource, if any.
3075        '''
3076        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3077        '''
3078         Tags is a map of key, value pairs.
3079        '''
3080        self.username = username if username is not None else ''
3081
3082    def __repr__(self):
3083        return '<sdm.Citus ' + \
3084            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3085            'database: ' + repr(self.database) + ' ' +\
3086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3087            'healthy: ' + repr(self.healthy) + ' ' +\
3088            'hostname: ' + repr(self.hostname) + ' ' +\
3089            'id: ' + repr(self.id) + ' ' +\
3090            'name: ' + repr(self.name) + ' ' +\
3091            'override_database: ' + repr(self.override_database) + ' ' +\
3092            'password: ' + repr(self.password) + ' ' +\
3093            'port: ' + repr(self.port) + ' ' +\
3094            'port_override: ' + repr(self.port_override) + ' ' +\
3095            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3096            'tags: ' + repr(self.tags) + ' ' +\
3097            'username: ' + repr(self.username) + ' ' +\
3098            '>'
3099
3100    def to_dict(self):
3101        return {
3102            'bind_interface': self.bind_interface,
3103            'database': self.database,
3104            'egress_filter': self.egress_filter,
3105            'healthy': self.healthy,
3106            'hostname': self.hostname,
3107            'id': self.id,
3108            'name': self.name,
3109            'override_database': self.override_database,
3110            'password': self.password,
3111            'port': self.port,
3112            'port_override': self.port_override,
3113            'secret_store_id': self.secret_store_id,
3114            'tags': self.tags,
3115            'username': self.username,
3116        }
3117
3118    @classmethod
3119    def from_dict(cls, d):
3120        return cls(
3121            bind_interface=d.get('bind_interface'),
3122            database=d.get('database'),
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            override_database=d.get('override_database'),
3129            password=d.get('password'),
3130            port=d.get('port'),
3131            port_override=d.get('port_override'),
3132            secret_store_id=d.get('secret_store_id'),
3133            tags=d.get('tags'),
3134            username=d.get('username'),
3135        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3029    def __init__(
3030        self,
3031        bind_interface=None,
3032        database=None,
3033        egress_filter=None,
3034        healthy=None,
3035        hostname=None,
3036        id=None,
3037        name=None,
3038        override_database=None,
3039        password=None,
3040        port=None,
3041        port_override=None,
3042        secret_store_id=None,
3043        tags=None,
3044        username=None,
3045    ):
3046        self.bind_interface = bind_interface if bind_interface is not None else ''
3047        '''
3048         Bind interface
3049        '''
3050        self.database = database if database is not None else ''
3051        self.egress_filter = egress_filter if egress_filter is not None else ''
3052        '''
3053         A filter applied to the routing logic to pin datasource to nodes.
3054        '''
3055        self.healthy = healthy if healthy is not None else False
3056        '''
3057         True if the datasource is reachable and the credentials are valid.
3058        '''
3059        self.hostname = hostname if hostname is not None else ''
3060        self.id = id if id is not None else ''
3061        '''
3062         Unique identifier of the Resource.
3063        '''
3064        self.name = name if name is not None else ''
3065        '''
3066         Unique human-readable name of the Resource.
3067        '''
3068        self.override_database = override_database if override_database is not None else False
3069        self.password = password if password is not None else ''
3070        self.port = port if port is not None else 0
3071        self.port_override = port_override if port_override is not None else 0
3072        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3073        '''
3074         ID of the secret store containing credentials for this resource, if any.
3075        '''
3076        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3077        '''
3078         Tags is a map of key, value pairs.
3079        '''
3080        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3100    def to_dict(self):
3101        return {
3102            'bind_interface': self.bind_interface,
3103            'database': self.database,
3104            'egress_filter': self.egress_filter,
3105            'healthy': self.healthy,
3106            'hostname': self.hostname,
3107            'id': self.id,
3108            'name': self.name,
3109            'override_database': self.override_database,
3110            'password': self.password,
3111            'port': self.port,
3112            'port_override': self.port_override,
3113            'secret_store_id': self.secret_store_id,
3114            'tags': self.tags,
3115            'username': self.username,
3116        }
@classmethod
def from_dict(cls, d)
3118    @classmethod
3119    def from_dict(cls, d):
3120        return cls(
3121            bind_interface=d.get('bind_interface'),
3122            database=d.get('database'),
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            override_database=d.get('override_database'),
3129            password=d.get('password'),
3130            port=d.get('port'),
3131            port_override=d.get('port_override'),
3132            secret_store_id=d.get('secret_store_id'),
3133            tags=d.get('tags'),
3134            username=d.get('username'),
3135        )
class Clustrix:
3138class Clustrix:
3139    __slots__ = [
3140        'bind_interface',
3141        'database',
3142        'egress_filter',
3143        'healthy',
3144        'hostname',
3145        'id',
3146        'name',
3147        'password',
3148        'port',
3149        'port_override',
3150        'secret_store_id',
3151        'tags',
3152        'username',
3153    ]
3154
3155    def __init__(
3156        self,
3157        bind_interface=None,
3158        database=None,
3159        egress_filter=None,
3160        healthy=None,
3161        hostname=None,
3162        id=None,
3163        name=None,
3164        password=None,
3165        port=None,
3166        port_override=None,
3167        secret_store_id=None,
3168        tags=None,
3169        username=None,
3170    ):
3171        self.bind_interface = bind_interface if bind_interface is not None else ''
3172        '''
3173         Bind interface
3174        '''
3175        self.database = database if database is not None else ''
3176        self.egress_filter = egress_filter if egress_filter is not None else ''
3177        '''
3178         A filter applied to the routing logic to pin datasource to nodes.
3179        '''
3180        self.healthy = healthy if healthy is not None else False
3181        '''
3182         True if the datasource is reachable and the credentials are valid.
3183        '''
3184        self.hostname = hostname if hostname is not None else ''
3185        self.id = id if id is not None else ''
3186        '''
3187         Unique identifier of the Resource.
3188        '''
3189        self.name = name if name is not None else ''
3190        '''
3191         Unique human-readable name of the Resource.
3192        '''
3193        self.password = password if password is not None else ''
3194        self.port = port if port is not None else 0
3195        self.port_override = port_override if port_override is not None else 0
3196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3197        '''
3198         ID of the secret store containing credentials for this resource, if any.
3199        '''
3200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3201        '''
3202         Tags is a map of key, value pairs.
3203        '''
3204        self.username = username if username is not None else ''
3205
3206    def __repr__(self):
3207        return '<sdm.Clustrix ' + \
3208            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3209            'database: ' + repr(self.database) + ' ' +\
3210            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3211            'healthy: ' + repr(self.healthy) + ' ' +\
3212            'hostname: ' + repr(self.hostname) + ' ' +\
3213            'id: ' + repr(self.id) + ' ' +\
3214            'name: ' + repr(self.name) + ' ' +\
3215            'password: ' + repr(self.password) + ' ' +\
3216            'port: ' + repr(self.port) + ' ' +\
3217            'port_override: ' + repr(self.port_override) + ' ' +\
3218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3219            'tags: ' + repr(self.tags) + ' ' +\
3220            'username: ' + repr(self.username) + ' ' +\
3221            '>'
3222
3223    def to_dict(self):
3224        return {
3225            'bind_interface': self.bind_interface,
3226            'database': self.database,
3227            'egress_filter': self.egress_filter,
3228            'healthy': self.healthy,
3229            'hostname': self.hostname,
3230            'id': self.id,
3231            'name': self.name,
3232            'password': self.password,
3233            'port': self.port,
3234            'port_override': self.port_override,
3235            'secret_store_id': self.secret_store_id,
3236            'tags': self.tags,
3237            'username': self.username,
3238        }
3239
3240    @classmethod
3241    def from_dict(cls, d):
3242        return cls(
3243            bind_interface=d.get('bind_interface'),
3244            database=d.get('database'),
3245            egress_filter=d.get('egress_filter'),
3246            healthy=d.get('healthy'),
3247            hostname=d.get('hostname'),
3248            id=d.get('id'),
3249            name=d.get('name'),
3250            password=d.get('password'),
3251            port=d.get('port'),
3252            port_override=d.get('port_override'),
3253            secret_store_id=d.get('secret_store_id'),
3254            tags=d.get('tags'),
3255            username=d.get('username'),
3256        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3155    def __init__(
3156        self,
3157        bind_interface=None,
3158        database=None,
3159        egress_filter=None,
3160        healthy=None,
3161        hostname=None,
3162        id=None,
3163        name=None,
3164        password=None,
3165        port=None,
3166        port_override=None,
3167        secret_store_id=None,
3168        tags=None,
3169        username=None,
3170    ):
3171        self.bind_interface = bind_interface if bind_interface is not None else ''
3172        '''
3173         Bind interface
3174        '''
3175        self.database = database if database is not None else ''
3176        self.egress_filter = egress_filter if egress_filter is not None else ''
3177        '''
3178         A filter applied to the routing logic to pin datasource to nodes.
3179        '''
3180        self.healthy = healthy if healthy is not None else False
3181        '''
3182         True if the datasource is reachable and the credentials are valid.
3183        '''
3184        self.hostname = hostname if hostname is not None else ''
3185        self.id = id if id is not None else ''
3186        '''
3187         Unique identifier of the Resource.
3188        '''
3189        self.name = name if name is not None else ''
3190        '''
3191         Unique human-readable name of the Resource.
3192        '''
3193        self.password = password if password is not None else ''
3194        self.port = port if port is not None else 0
3195        self.port_override = port_override if port_override is not None else 0
3196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3197        '''
3198         ID of the secret store containing credentials for this resource, if any.
3199        '''
3200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3201        '''
3202         Tags is a map of key, value pairs.
3203        '''
3204        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3223    def to_dict(self):
3224        return {
3225            'bind_interface': self.bind_interface,
3226            'database': self.database,
3227            'egress_filter': self.egress_filter,
3228            'healthy': self.healthy,
3229            'hostname': self.hostname,
3230            'id': self.id,
3231            'name': self.name,
3232            'password': self.password,
3233            'port': self.port,
3234            'port_override': self.port_override,
3235            'secret_store_id': self.secret_store_id,
3236            'tags': self.tags,
3237            'username': self.username,
3238        }
@classmethod
def from_dict(cls, d)
3240    @classmethod
3241    def from_dict(cls, d):
3242        return cls(
3243            bind_interface=d.get('bind_interface'),
3244            database=d.get('database'),
3245            egress_filter=d.get('egress_filter'),
3246            healthy=d.get('healthy'),
3247            hostname=d.get('hostname'),
3248            id=d.get('id'),
3249            name=d.get('name'),
3250            password=d.get('password'),
3251            port=d.get('port'),
3252            port_override=d.get('port_override'),
3253            secret_store_id=d.get('secret_store_id'),
3254            tags=d.get('tags'),
3255            username=d.get('username'),
3256        )
class Cockroach:
3259class Cockroach:
3260    __slots__ = [
3261        'bind_interface',
3262        'database',
3263        'egress_filter',
3264        'healthy',
3265        'hostname',
3266        'id',
3267        'name',
3268        'override_database',
3269        'password',
3270        'port',
3271        'port_override',
3272        'secret_store_id',
3273        'tags',
3274        'username',
3275    ]
3276
3277    def __init__(
3278        self,
3279        bind_interface=None,
3280        database=None,
3281        egress_filter=None,
3282        healthy=None,
3283        hostname=None,
3284        id=None,
3285        name=None,
3286        override_database=None,
3287        password=None,
3288        port=None,
3289        port_override=None,
3290        secret_store_id=None,
3291        tags=None,
3292        username=None,
3293    ):
3294        self.bind_interface = bind_interface if bind_interface is not None else ''
3295        '''
3296         Bind interface
3297        '''
3298        self.database = database if database is not None else ''
3299        self.egress_filter = egress_filter if egress_filter is not None else ''
3300        '''
3301         A filter applied to the routing logic to pin datasource to nodes.
3302        '''
3303        self.healthy = healthy if healthy is not None else False
3304        '''
3305         True if the datasource is reachable and the credentials are valid.
3306        '''
3307        self.hostname = hostname if hostname is not None else ''
3308        self.id = id if id is not None else ''
3309        '''
3310         Unique identifier of the Resource.
3311        '''
3312        self.name = name if name is not None else ''
3313        '''
3314         Unique human-readable name of the Resource.
3315        '''
3316        self.override_database = override_database if override_database is not None else False
3317        self.password = password if password is not None else ''
3318        self.port = port if port is not None else 0
3319        self.port_override = port_override if port_override is not None else 0
3320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3321        '''
3322         ID of the secret store containing credentials for this resource, if any.
3323        '''
3324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3325        '''
3326         Tags is a map of key, value pairs.
3327        '''
3328        self.username = username if username is not None else ''
3329
3330    def __repr__(self):
3331        return '<sdm.Cockroach ' + \
3332            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3333            'database: ' + repr(self.database) + ' ' +\
3334            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3335            'healthy: ' + repr(self.healthy) + ' ' +\
3336            'hostname: ' + repr(self.hostname) + ' ' +\
3337            'id: ' + repr(self.id) + ' ' +\
3338            'name: ' + repr(self.name) + ' ' +\
3339            'override_database: ' + repr(self.override_database) + ' ' +\
3340            'password: ' + repr(self.password) + ' ' +\
3341            'port: ' + repr(self.port) + ' ' +\
3342            'port_override: ' + repr(self.port_override) + ' ' +\
3343            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3344            'tags: ' + repr(self.tags) + ' ' +\
3345            'username: ' + repr(self.username) + ' ' +\
3346            '>'
3347
3348    def to_dict(self):
3349        return {
3350            'bind_interface': self.bind_interface,
3351            'database': self.database,
3352            'egress_filter': self.egress_filter,
3353            'healthy': self.healthy,
3354            'hostname': self.hostname,
3355            'id': self.id,
3356            'name': self.name,
3357            'override_database': self.override_database,
3358            'password': self.password,
3359            'port': self.port,
3360            'port_override': self.port_override,
3361            'secret_store_id': self.secret_store_id,
3362            'tags': self.tags,
3363            'username': self.username,
3364        }
3365
3366    @classmethod
3367    def from_dict(cls, d):
3368        return cls(
3369            bind_interface=d.get('bind_interface'),
3370            database=d.get('database'),
3371            egress_filter=d.get('egress_filter'),
3372            healthy=d.get('healthy'),
3373            hostname=d.get('hostname'),
3374            id=d.get('id'),
3375            name=d.get('name'),
3376            override_database=d.get('override_database'),
3377            password=d.get('password'),
3378            port=d.get('port'),
3379            port_override=d.get('port_override'),
3380            secret_store_id=d.get('secret_store_id'),
3381            tags=d.get('tags'),
3382            username=d.get('username'),
3383        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3277    def __init__(
3278        self,
3279        bind_interface=None,
3280        database=None,
3281        egress_filter=None,
3282        healthy=None,
3283        hostname=None,
3284        id=None,
3285        name=None,
3286        override_database=None,
3287        password=None,
3288        port=None,
3289        port_override=None,
3290        secret_store_id=None,
3291        tags=None,
3292        username=None,
3293    ):
3294        self.bind_interface = bind_interface if bind_interface is not None else ''
3295        '''
3296         Bind interface
3297        '''
3298        self.database = database if database is not None else ''
3299        self.egress_filter = egress_filter if egress_filter is not None else ''
3300        '''
3301         A filter applied to the routing logic to pin datasource to nodes.
3302        '''
3303        self.healthy = healthy if healthy is not None else False
3304        '''
3305         True if the datasource is reachable and the credentials are valid.
3306        '''
3307        self.hostname = hostname if hostname is not None else ''
3308        self.id = id if id is not None else ''
3309        '''
3310         Unique identifier of the Resource.
3311        '''
3312        self.name = name if name is not None else ''
3313        '''
3314         Unique human-readable name of the Resource.
3315        '''
3316        self.override_database = override_database if override_database is not None else False
3317        self.password = password if password is not None else ''
3318        self.port = port if port is not None else 0
3319        self.port_override = port_override if port_override is not None else 0
3320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3321        '''
3322         ID of the secret store containing credentials for this resource, if any.
3323        '''
3324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3325        '''
3326         Tags is a map of key, value pairs.
3327        '''
3328        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3348    def to_dict(self):
3349        return {
3350            'bind_interface': self.bind_interface,
3351            'database': self.database,
3352            'egress_filter': self.egress_filter,
3353            'healthy': self.healthy,
3354            'hostname': self.hostname,
3355            'id': self.id,
3356            'name': self.name,
3357            'override_database': self.override_database,
3358            'password': self.password,
3359            'port': self.port,
3360            'port_override': self.port_override,
3361            'secret_store_id': self.secret_store_id,
3362            'tags': self.tags,
3363            'username': self.username,
3364        }
@classmethod
def from_dict(cls, d)
3366    @classmethod
3367    def from_dict(cls, d):
3368        return cls(
3369            bind_interface=d.get('bind_interface'),
3370            database=d.get('database'),
3371            egress_filter=d.get('egress_filter'),
3372            healthy=d.get('healthy'),
3373            hostname=d.get('hostname'),
3374            id=d.get('id'),
3375            name=d.get('name'),
3376            override_database=d.get('override_database'),
3377            password=d.get('password'),
3378            port=d.get('port'),
3379            port_override=d.get('port_override'),
3380            secret_store_id=d.get('secret_store_id'),
3381            tags=d.get('tags'),
3382            username=d.get('username'),
3383        )
class ConjurClientStore:
3386class ConjurClientStore:
3387    '''
3388    ConjurClientStore is currently unstable, and its API may change, or it may be removed,
3389    without a major version bump.
3390    '''
3391    __slots__ = [
3392        'appurl',
3393        'id',
3394        'name',
3395        'tags',
3396    ]
3397
3398    def __init__(
3399        self,
3400        appurl=None,
3401        id=None,
3402        name=None,
3403        tags=None,
3404    ):
3405        self.appurl = appurl if appurl is not None else ''
3406        self.id = id if id is not None else ''
3407        '''
3408         Unique identifier of the SecretStore.
3409        '''
3410        self.name = name if name is not None else ''
3411        '''
3412         Unique human-readable name of the SecretStore.
3413        '''
3414        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3415        '''
3416         Tags is a map of key, value pairs.
3417        '''
3418
3419    def __repr__(self):
3420        return '<sdm.ConjurClientStore ' + \
3421            'appurl: ' + repr(self.appurl) + ' ' +\
3422            'id: ' + repr(self.id) + ' ' +\
3423            'name: ' + repr(self.name) + ' ' +\
3424            'tags: ' + repr(self.tags) + ' ' +\
3425            '>'
3426
3427    def to_dict(self):
3428        return {
3429            'appurl': self.appurl,
3430            'id': self.id,
3431            'name': self.name,
3432            'tags': self.tags,
3433        }
3434
3435    @classmethod
3436    def from_dict(cls, d):
3437        return cls(
3438            appurl=d.get('appurl'),
3439            id=d.get('id'),
3440            name=d.get('name'),
3441            tags=d.get('tags'),
3442        )

ConjurClientStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

ConjurClientStore(appurl=None, id=None, name=None, tags=None)
3398    def __init__(
3399        self,
3400        appurl=None,
3401        id=None,
3402        name=None,
3403        tags=None,
3404    ):
3405        self.appurl = appurl if appurl is not None else ''
3406        self.id = id if id is not None else ''
3407        '''
3408         Unique identifier of the SecretStore.
3409        '''
3410        self.name = name if name is not None else ''
3411        '''
3412         Unique human-readable name of the SecretStore.
3413        '''
3414        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3415        '''
3416         Tags is a map of key, value pairs.
3417        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3427    def to_dict(self):
3428        return {
3429            'appurl': self.appurl,
3430            'id': self.id,
3431            'name': self.name,
3432            'tags': self.tags,
3433        }
@classmethod
def from_dict(cls, d)
3435    @classmethod
3436    def from_dict(cls, d):
3437        return cls(
3438            appurl=d.get('appurl'),
3439            id=d.get('id'),
3440            name=d.get('name'),
3441            tags=d.get('tags'),
3442        )
class ControlPanelGetSSHCAPublicKeyResponse:
3445class ControlPanelGetSSHCAPublicKeyResponse:
3446    '''
3447         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3448     organization's SSH Certificate Authority public key.
3449    '''
3450    __slots__ = [
3451        'meta',
3452        'public_key',
3453        'rate_limit',
3454    ]
3455
3456    def __init__(
3457        self,
3458        meta=None,
3459        public_key=None,
3460        rate_limit=None,
3461    ):
3462        self.meta = meta if meta is not None else None
3463        '''
3464         Reserved for future use.
3465        '''
3466        self.public_key = public_key if public_key is not None else ''
3467        '''
3468         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3469         key format.
3470        '''
3471        self.rate_limit = rate_limit if rate_limit is not None else None
3472        '''
3473         Rate limit information.
3474        '''
3475
3476    def __repr__(self):
3477        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3478            'meta: ' + repr(self.meta) + ' ' +\
3479            'public_key: ' + repr(self.public_key) + ' ' +\
3480            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3481            '>'
3482
3483    def to_dict(self):
3484        return {
3485            'meta': self.meta,
3486            'public_key': self.public_key,
3487            'rate_limit': self.rate_limit,
3488        }
3489
3490    @classmethod
3491    def from_dict(cls, d):
3492        return cls(
3493            meta=d.get('meta'),
3494            public_key=d.get('public_key'),
3495            rate_limit=d.get('rate_limit'),
3496        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3456    def __init__(
3457        self,
3458        meta=None,
3459        public_key=None,
3460        rate_limit=None,
3461    ):
3462        self.meta = meta if meta is not None else None
3463        '''
3464         Reserved for future use.
3465        '''
3466        self.public_key = public_key if public_key is not None else ''
3467        '''
3468         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3469         key format.
3470        '''
3471        self.rate_limit = rate_limit if rate_limit is not None else None
3472        '''
3473         Rate limit information.
3474        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3483    def to_dict(self):
3484        return {
3485            'meta': self.meta,
3486            'public_key': self.public_key,
3487            'rate_limit': self.rate_limit,
3488        }
@classmethod
def from_dict(cls, d)
3490    @classmethod
3491    def from_dict(cls, d):
3492        return cls(
3493            meta=d.get('meta'),
3494            public_key=d.get('public_key'),
3495            rate_limit=d.get('rate_limit'),
3496        )
class ControlPanelVerifyJWTResponse:
3499class ControlPanelVerifyJWTResponse:
3500    '''
3501         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3502    '''
3503    __slots__ = [
3504        'meta',
3505        'rate_limit',
3506        'valid',
3507    ]
3508
3509    def __init__(
3510        self,
3511        meta=None,
3512        rate_limit=None,
3513        valid=None,
3514    ):
3515        self.meta = meta if meta is not None else None
3516        '''
3517         Reserved for future use.
3518        '''
3519        self.rate_limit = rate_limit if rate_limit is not None else None
3520        '''
3521         Rate limit information.
3522        '''
3523        self.valid = valid if valid is not None else False
3524        '''
3525         Reports if the given token is valid.
3526        '''
3527
3528    def __repr__(self):
3529        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3530            'meta: ' + repr(self.meta) + ' ' +\
3531            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3532            'valid: ' + repr(self.valid) + ' ' +\
3533            '>'
3534
3535    def to_dict(self):
3536        return {
3537            'meta': self.meta,
3538            'rate_limit': self.rate_limit,
3539            'valid': self.valid,
3540        }
3541
3542    @classmethod
3543    def from_dict(cls, d):
3544        return cls(
3545            meta=d.get('meta'),
3546            rate_limit=d.get('rate_limit'),
3547            valid=d.get('valid'),
3548        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3509    def __init__(
3510        self,
3511        meta=None,
3512        rate_limit=None,
3513        valid=None,
3514    ):
3515        self.meta = meta if meta is not None else None
3516        '''
3517         Reserved for future use.
3518        '''
3519        self.rate_limit = rate_limit if rate_limit is not None else None
3520        '''
3521         Rate limit information.
3522        '''
3523        self.valid = valid if valid is not None else False
3524        '''
3525         Reports if the given token is valid.
3526        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3535    def to_dict(self):
3536        return {
3537            'meta': self.meta,
3538            'rate_limit': self.rate_limit,
3539            'valid': self.valid,
3540        }
@classmethod
def from_dict(cls, d)
3542    @classmethod
3543    def from_dict(cls, d):
3544        return cls(
3545            meta=d.get('meta'),
3546            rate_limit=d.get('rate_limit'),
3547            valid=d.get('valid'),
3548        )
class CreateResponseMetadata:
3551class CreateResponseMetadata:
3552    '''
3553         CreateResponseMetadata is reserved for future use.
3554    '''
3555    __slots__ = []
3556
3557    def __init__(self, ):
3558        pass
3559
3560    def __repr__(self):
3561        return '<sdm.CreateResponseMetadata ' + \
3562            '>'
3563
3564    def to_dict(self):
3565        return {}
3566
3567    @classmethod
3568    def from_dict(cls, d):
3569        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3557    def __init__(self, ):
3558        pass
def to_dict(self)
3564    def to_dict(self):
3565        return {}
@classmethod
def from_dict(cls, d)
3567    @classmethod
3568    def from_dict(cls, d):
3569        return cls()
class DB2I:
3572class DB2I:
3573    __slots__ = [
3574        'bind_interface',
3575        'egress_filter',
3576        'healthy',
3577        'hostname',
3578        'id',
3579        'name',
3580        'password',
3581        'port',
3582        'port_override',
3583        'secret_store_id',
3584        'tags',
3585        'tls_required',
3586        'username',
3587    ]
3588
3589    def __init__(
3590        self,
3591        bind_interface=None,
3592        egress_filter=None,
3593        healthy=None,
3594        hostname=None,
3595        id=None,
3596        name=None,
3597        password=None,
3598        port=None,
3599        port_override=None,
3600        secret_store_id=None,
3601        tags=None,
3602        tls_required=None,
3603        username=None,
3604    ):
3605        self.bind_interface = bind_interface if bind_interface is not None else ''
3606        '''
3607         Bind interface
3608        '''
3609        self.egress_filter = egress_filter if egress_filter is not None else ''
3610        '''
3611         A filter applied to the routing logic to pin datasource to nodes.
3612        '''
3613        self.healthy = healthy if healthy is not None else False
3614        '''
3615         True if the datasource is reachable and the credentials are valid.
3616        '''
3617        self.hostname = hostname if hostname is not None else ''
3618        self.id = id if id is not None else ''
3619        '''
3620         Unique identifier of the Resource.
3621        '''
3622        self.name = name if name is not None else ''
3623        '''
3624         Unique human-readable name of the Resource.
3625        '''
3626        self.password = password if password is not None else ''
3627        self.port = port if port is not None else 0
3628        self.port_override = port_override if port_override is not None else 0
3629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3630        '''
3631         ID of the secret store containing credentials for this resource, if any.
3632        '''
3633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3634        '''
3635         Tags is a map of key, value pairs.
3636        '''
3637        self.tls_required = tls_required if tls_required is not None else False
3638        self.username = username if username is not None else ''
3639
3640    def __repr__(self):
3641        return '<sdm.DB2I ' + \
3642            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3643            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3644            'healthy: ' + repr(self.healthy) + ' ' +\
3645            'hostname: ' + repr(self.hostname) + ' ' +\
3646            'id: ' + repr(self.id) + ' ' +\
3647            'name: ' + repr(self.name) + ' ' +\
3648            'password: ' + repr(self.password) + ' ' +\
3649            'port: ' + repr(self.port) + ' ' +\
3650            'port_override: ' + repr(self.port_override) + ' ' +\
3651            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3652            'tags: ' + repr(self.tags) + ' ' +\
3653            'tls_required: ' + repr(self.tls_required) + ' ' +\
3654            'username: ' + repr(self.username) + ' ' +\
3655            '>'
3656
3657    def to_dict(self):
3658        return {
3659            'bind_interface': self.bind_interface,
3660            'egress_filter': self.egress_filter,
3661            'healthy': self.healthy,
3662            'hostname': self.hostname,
3663            'id': self.id,
3664            'name': self.name,
3665            'password': self.password,
3666            'port': self.port,
3667            'port_override': self.port_override,
3668            'secret_store_id': self.secret_store_id,
3669            'tags': self.tags,
3670            'tls_required': self.tls_required,
3671            'username': self.username,
3672        }
3673
3674    @classmethod
3675    def from_dict(cls, d):
3676        return cls(
3677            bind_interface=d.get('bind_interface'),
3678            egress_filter=d.get('egress_filter'),
3679            healthy=d.get('healthy'),
3680            hostname=d.get('hostname'),
3681            id=d.get('id'),
3682            name=d.get('name'),
3683            password=d.get('password'),
3684            port=d.get('port'),
3685            port_override=d.get('port_override'),
3686            secret_store_id=d.get('secret_store_id'),
3687            tags=d.get('tags'),
3688            tls_required=d.get('tls_required'),
3689            username=d.get('username'),
3690        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3589    def __init__(
3590        self,
3591        bind_interface=None,
3592        egress_filter=None,
3593        healthy=None,
3594        hostname=None,
3595        id=None,
3596        name=None,
3597        password=None,
3598        port=None,
3599        port_override=None,
3600        secret_store_id=None,
3601        tags=None,
3602        tls_required=None,
3603        username=None,
3604    ):
3605        self.bind_interface = bind_interface if bind_interface is not None else ''
3606        '''
3607         Bind interface
3608        '''
3609        self.egress_filter = egress_filter if egress_filter is not None else ''
3610        '''
3611         A filter applied to the routing logic to pin datasource to nodes.
3612        '''
3613        self.healthy = healthy if healthy is not None else False
3614        '''
3615         True if the datasource is reachable and the credentials are valid.
3616        '''
3617        self.hostname = hostname if hostname is not None else ''
3618        self.id = id if id is not None else ''
3619        '''
3620         Unique identifier of the Resource.
3621        '''
3622        self.name = name if name is not None else ''
3623        '''
3624         Unique human-readable name of the Resource.
3625        '''
3626        self.password = password if password is not None else ''
3627        self.port = port if port is not None else 0
3628        self.port_override = port_override if port_override is not None else 0
3629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3630        '''
3631         ID of the secret store containing credentials for this resource, if any.
3632        '''
3633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3634        '''
3635         Tags is a map of key, value pairs.
3636        '''
3637        self.tls_required = tls_required if tls_required is not None else False
3638        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3657    def to_dict(self):
3658        return {
3659            'bind_interface': self.bind_interface,
3660            'egress_filter': self.egress_filter,
3661            'healthy': self.healthy,
3662            'hostname': self.hostname,
3663            'id': self.id,
3664            'name': self.name,
3665            'password': self.password,
3666            'port': self.port,
3667            'port_override': self.port_override,
3668            'secret_store_id': self.secret_store_id,
3669            'tags': self.tags,
3670            'tls_required': self.tls_required,
3671            'username': self.username,
3672        }
@classmethod
def from_dict(cls, d)
3674    @classmethod
3675    def from_dict(cls, d):
3676        return cls(
3677            bind_interface=d.get('bind_interface'),
3678            egress_filter=d.get('egress_filter'),
3679            healthy=d.get('healthy'),
3680            hostname=d.get('hostname'),
3681            id=d.get('id'),
3682            name=d.get('name'),
3683            password=d.get('password'),
3684            port=d.get('port'),
3685            port_override=d.get('port_override'),
3686            secret_store_id=d.get('secret_store_id'),
3687            tags=d.get('tags'),
3688            tls_required=d.get('tls_required'),
3689            username=d.get('username'),
3690        )
class DB2LUW:
3693class DB2LUW:
3694    __slots__ = [
3695        'bind_interface',
3696        'database',
3697        'egress_filter',
3698        'healthy',
3699        'hostname',
3700        'id',
3701        'name',
3702        'password',
3703        'port',
3704        'port_override',
3705        'secret_store_id',
3706        'tags',
3707        'username',
3708    ]
3709
3710    def __init__(
3711        self,
3712        bind_interface=None,
3713        database=None,
3714        egress_filter=None,
3715        healthy=None,
3716        hostname=None,
3717        id=None,
3718        name=None,
3719        password=None,
3720        port=None,
3721        port_override=None,
3722        secret_store_id=None,
3723        tags=None,
3724        username=None,
3725    ):
3726        self.bind_interface = bind_interface if bind_interface is not None else ''
3727        '''
3728         Bind interface
3729        '''
3730        self.database = database if database is not None else ''
3731        self.egress_filter = egress_filter if egress_filter is not None else ''
3732        '''
3733         A filter applied to the routing logic to pin datasource to nodes.
3734        '''
3735        self.healthy = healthy if healthy is not None else False
3736        '''
3737         True if the datasource is reachable and the credentials are valid.
3738        '''
3739        self.hostname = hostname if hostname is not None else ''
3740        self.id = id if id is not None else ''
3741        '''
3742         Unique identifier of the Resource.
3743        '''
3744        self.name = name if name is not None else ''
3745        '''
3746         Unique human-readable name of the Resource.
3747        '''
3748        self.password = password if password is not None else ''
3749        self.port = port if port is not None else 0
3750        self.port_override = port_override if port_override is not None else 0
3751        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3752        '''
3753         ID of the secret store containing credentials for this resource, if any.
3754        '''
3755        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3756        '''
3757         Tags is a map of key, value pairs.
3758        '''
3759        self.username = username if username is not None else ''
3760
3761    def __repr__(self):
3762        return '<sdm.DB2LUW ' + \
3763            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3764            'database: ' + repr(self.database) + ' ' +\
3765            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3766            'healthy: ' + repr(self.healthy) + ' ' +\
3767            'hostname: ' + repr(self.hostname) + ' ' +\
3768            'id: ' + repr(self.id) + ' ' +\
3769            'name: ' + repr(self.name) + ' ' +\
3770            'password: ' + repr(self.password) + ' ' +\
3771            'port: ' + repr(self.port) + ' ' +\
3772            'port_override: ' + repr(self.port_override) + ' ' +\
3773            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3774            'tags: ' + repr(self.tags) + ' ' +\
3775            'username: ' + repr(self.username) + ' ' +\
3776            '>'
3777
3778    def to_dict(self):
3779        return {
3780            'bind_interface': self.bind_interface,
3781            'database': self.database,
3782            'egress_filter': self.egress_filter,
3783            'healthy': self.healthy,
3784            'hostname': self.hostname,
3785            'id': self.id,
3786            'name': self.name,
3787            'password': self.password,
3788            'port': self.port,
3789            'port_override': self.port_override,
3790            'secret_store_id': self.secret_store_id,
3791            'tags': self.tags,
3792            'username': self.username,
3793        }
3794
3795    @classmethod
3796    def from_dict(cls, d):
3797        return cls(
3798            bind_interface=d.get('bind_interface'),
3799            database=d.get('database'),
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            username=d.get('username'),
3811        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3710    def __init__(
3711        self,
3712        bind_interface=None,
3713        database=None,
3714        egress_filter=None,
3715        healthy=None,
3716        hostname=None,
3717        id=None,
3718        name=None,
3719        password=None,
3720        port=None,
3721        port_override=None,
3722        secret_store_id=None,
3723        tags=None,
3724        username=None,
3725    ):
3726        self.bind_interface = bind_interface if bind_interface is not None else ''
3727        '''
3728         Bind interface
3729        '''
3730        self.database = database if database is not None else ''
3731        self.egress_filter = egress_filter if egress_filter is not None else ''
3732        '''
3733         A filter applied to the routing logic to pin datasource to nodes.
3734        '''
3735        self.healthy = healthy if healthy is not None else False
3736        '''
3737         True if the datasource is reachable and the credentials are valid.
3738        '''
3739        self.hostname = hostname if hostname is not None else ''
3740        self.id = id if id is not None else ''
3741        '''
3742         Unique identifier of the Resource.
3743        '''
3744        self.name = name if name is not None else ''
3745        '''
3746         Unique human-readable name of the Resource.
3747        '''
3748        self.password = password if password is not None else ''
3749        self.port = port if port is not None else 0
3750        self.port_override = port_override if port_override is not None else 0
3751        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3752        '''
3753         ID of the secret store containing credentials for this resource, if any.
3754        '''
3755        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3756        '''
3757         Tags is a map of key, value pairs.
3758        '''
3759        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3778    def to_dict(self):
3779        return {
3780            'bind_interface': self.bind_interface,
3781            'database': self.database,
3782            'egress_filter': self.egress_filter,
3783            'healthy': self.healthy,
3784            'hostname': self.hostname,
3785            'id': self.id,
3786            'name': self.name,
3787            'password': self.password,
3788            'port': self.port,
3789            'port_override': self.port_override,
3790            'secret_store_id': self.secret_store_id,
3791            'tags': self.tags,
3792            'username': self.username,
3793        }
@classmethod
def from_dict(cls, d)
3795    @classmethod
3796    def from_dict(cls, d):
3797        return cls(
3798            bind_interface=d.get('bind_interface'),
3799            database=d.get('database'),
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            username=d.get('username'),
3811        )
class DeleteResponseMetadata:
3814class DeleteResponseMetadata:
3815    '''
3816         DeleteResponseMetadata is reserved for future use.
3817    '''
3818    __slots__ = []
3819
3820    def __init__(self, ):
3821        pass
3822
3823    def __repr__(self):
3824        return '<sdm.DeleteResponseMetadata ' + \
3825            '>'
3826
3827    def to_dict(self):
3828        return {}
3829
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
3820    def __init__(self, ):
3821        pass
def to_dict(self)
3827    def to_dict(self):
3828        return {}
@classmethod
def from_dict(cls, d)
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls()
class DelineaStore:
3835class DelineaStore:
3836    '''
3837    DelineaStore is currently unstable, and its API may change, or it may be removed,
3838    without a major version bump.
3839    '''
3840    __slots__ = [
3841        'id',
3842        'name',
3843        'server_url',
3844        'tags',
3845        'tenant_name',
3846    ]
3847
3848    def __init__(
3849        self,
3850        id=None,
3851        name=None,
3852        server_url=None,
3853        tags=None,
3854        tenant_name=None,
3855    ):
3856        self.id = id if id is not None else ''
3857        '''
3858         Unique identifier of the SecretStore.
3859        '''
3860        self.name = name if name is not None else ''
3861        '''
3862         Unique human-readable name of the SecretStore.
3863        '''
3864        self.server_url = server_url if server_url is not None else ''
3865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3866        '''
3867         Tags is a map of key, value pairs.
3868        '''
3869        self.tenant_name = tenant_name if tenant_name is not None else ''
3870
3871    def __repr__(self):
3872        return '<sdm.DelineaStore ' + \
3873            'id: ' + repr(self.id) + ' ' +\
3874            'name: ' + repr(self.name) + ' ' +\
3875            'server_url: ' + repr(self.server_url) + ' ' +\
3876            'tags: ' + repr(self.tags) + ' ' +\
3877            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
3878            '>'
3879
3880    def to_dict(self):
3881        return {
3882            'id': self.id,
3883            'name': self.name,
3884            'server_url': self.server_url,
3885            'tags': self.tags,
3886            'tenant_name': self.tenant_name,
3887        }
3888
3889    @classmethod
3890    def from_dict(cls, d):
3891        return cls(
3892            id=d.get('id'),
3893            name=d.get('name'),
3894            server_url=d.get('server_url'),
3895            tags=d.get('tags'),
3896            tenant_name=d.get('tenant_name'),
3897        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
3848    def __init__(
3849        self,
3850        id=None,
3851        name=None,
3852        server_url=None,
3853        tags=None,
3854        tenant_name=None,
3855    ):
3856        self.id = id if id is not None else ''
3857        '''
3858         Unique identifier of the SecretStore.
3859        '''
3860        self.name = name if name is not None else ''
3861        '''
3862         Unique human-readable name of the SecretStore.
3863        '''
3864        self.server_url = server_url if server_url is not None else ''
3865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3866        '''
3867         Tags is a map of key, value pairs.
3868        '''
3869        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
3880    def to_dict(self):
3881        return {
3882            'id': self.id,
3883            'name': self.name,
3884            'server_url': self.server_url,
3885            'tags': self.tags,
3886            'tenant_name': self.tenant_name,
3887        }
@classmethod
def from_dict(cls, d)
3889    @classmethod
3890    def from_dict(cls, d):
3891        return cls(
3892            id=d.get('id'),
3893            name=d.get('name'),
3894            server_url=d.get('server_url'),
3895            tags=d.get('tags'),
3896            tenant_name=d.get('tenant_name'),
3897        )
class DocumentDBHost:
3900class DocumentDBHost:
3901    __slots__ = [
3902        'auth_database',
3903        'bind_interface',
3904        'egress_filter',
3905        'healthy',
3906        'hostname',
3907        'id',
3908        'name',
3909        'password',
3910        'port',
3911        'port_override',
3912        'secret_store_id',
3913        'tags',
3914        'username',
3915    ]
3916
3917    def __init__(
3918        self,
3919        auth_database=None,
3920        bind_interface=None,
3921        egress_filter=None,
3922        healthy=None,
3923        hostname=None,
3924        id=None,
3925        name=None,
3926        password=None,
3927        port=None,
3928        port_override=None,
3929        secret_store_id=None,
3930        tags=None,
3931        username=None,
3932    ):
3933        self.auth_database = auth_database if auth_database is not None else ''
3934        self.bind_interface = bind_interface if bind_interface is not None else ''
3935        '''
3936         Bind interface
3937        '''
3938        self.egress_filter = egress_filter if egress_filter is not None else ''
3939        '''
3940         A filter applied to the routing logic to pin datasource to nodes.
3941        '''
3942        self.healthy = healthy if healthy is not None else False
3943        '''
3944         True if the datasource is reachable and the credentials are valid.
3945        '''
3946        self.hostname = hostname if hostname is not None else ''
3947        self.id = id if id is not None else ''
3948        '''
3949         Unique identifier of the Resource.
3950        '''
3951        self.name = name if name is not None else ''
3952        '''
3953         Unique human-readable name of the Resource.
3954        '''
3955        self.password = password if password is not None else ''
3956        self.port = port if port is not None else 0
3957        self.port_override = port_override if port_override is not None else 0
3958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3959        '''
3960         ID of the secret store containing credentials for this resource, if any.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966        self.username = username if username is not None else ''
3967
3968    def __repr__(self):
3969        return '<sdm.DocumentDBHost ' + \
3970            'auth_database: ' + repr(self.auth_database) + ' ' +\
3971            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3972            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3973            'healthy: ' + repr(self.healthy) + ' ' +\
3974            'hostname: ' + repr(self.hostname) + ' ' +\
3975            'id: ' + repr(self.id) + ' ' +\
3976            'name: ' + repr(self.name) + ' ' +\
3977            'password: ' + repr(self.password) + ' ' +\
3978            'port: ' + repr(self.port) + ' ' +\
3979            'port_override: ' + repr(self.port_override) + ' ' +\
3980            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3981            'tags: ' + repr(self.tags) + ' ' +\
3982            'username: ' + repr(self.username) + ' ' +\
3983            '>'
3984
3985    def to_dict(self):
3986        return {
3987            'auth_database': self.auth_database,
3988            'bind_interface': self.bind_interface,
3989            'egress_filter': self.egress_filter,
3990            'healthy': self.healthy,
3991            'hostname': self.hostname,
3992            'id': self.id,
3993            'name': self.name,
3994            'password': self.password,
3995            'port': self.port,
3996            'port_override': self.port_override,
3997            'secret_store_id': self.secret_store_id,
3998            'tags': self.tags,
3999            'username': self.username,
4000        }
4001
4002    @classmethod
4003    def from_dict(cls, d):
4004        return cls(
4005            auth_database=d.get('auth_database'),
4006            bind_interface=d.get('bind_interface'),
4007            egress_filter=d.get('egress_filter'),
4008            healthy=d.get('healthy'),
4009            hostname=d.get('hostname'),
4010            id=d.get('id'),
4011            name=d.get('name'),
4012            password=d.get('password'),
4013            port=d.get('port'),
4014            port_override=d.get('port_override'),
4015            secret_store_id=d.get('secret_store_id'),
4016            tags=d.get('tags'),
4017            username=d.get('username'),
4018        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3917    def __init__(
3918        self,
3919        auth_database=None,
3920        bind_interface=None,
3921        egress_filter=None,
3922        healthy=None,
3923        hostname=None,
3924        id=None,
3925        name=None,
3926        password=None,
3927        port=None,
3928        port_override=None,
3929        secret_store_id=None,
3930        tags=None,
3931        username=None,
3932    ):
3933        self.auth_database = auth_database if auth_database is not None else ''
3934        self.bind_interface = bind_interface if bind_interface is not None else ''
3935        '''
3936         Bind interface
3937        '''
3938        self.egress_filter = egress_filter if egress_filter is not None else ''
3939        '''
3940         A filter applied to the routing logic to pin datasource to nodes.
3941        '''
3942        self.healthy = healthy if healthy is not None else False
3943        '''
3944         True if the datasource is reachable and the credentials are valid.
3945        '''
3946        self.hostname = hostname if hostname is not None else ''
3947        self.id = id if id is not None else ''
3948        '''
3949         Unique identifier of the Resource.
3950        '''
3951        self.name = name if name is not None else ''
3952        '''
3953         Unique human-readable name of the Resource.
3954        '''
3955        self.password = password if password is not None else ''
3956        self.port = port if port is not None else 0
3957        self.port_override = port_override if port_override is not None else 0
3958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3959        '''
3960         ID of the secret store containing credentials for this resource, if any.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3985    def to_dict(self):
3986        return {
3987            'auth_database': self.auth_database,
3988            'bind_interface': self.bind_interface,
3989            'egress_filter': self.egress_filter,
3990            'healthy': self.healthy,
3991            'hostname': self.hostname,
3992            'id': self.id,
3993            'name': self.name,
3994            'password': self.password,
3995            'port': self.port,
3996            'port_override': self.port_override,
3997            'secret_store_id': self.secret_store_id,
3998            'tags': self.tags,
3999            'username': self.username,
4000        }
@classmethod
def from_dict(cls, d)
4002    @classmethod
4003    def from_dict(cls, d):
4004        return cls(
4005            auth_database=d.get('auth_database'),
4006            bind_interface=d.get('bind_interface'),
4007            egress_filter=d.get('egress_filter'),
4008            healthy=d.get('healthy'),
4009            hostname=d.get('hostname'),
4010            id=d.get('id'),
4011            name=d.get('name'),
4012            password=d.get('password'),
4013            port=d.get('port'),
4014            port_override=d.get('port_override'),
4015            secret_store_id=d.get('secret_store_id'),
4016            tags=d.get('tags'),
4017            username=d.get('username'),
4018        )
class DocumentDBReplicaSet:
4021class DocumentDBReplicaSet:
4022    __slots__ = [
4023        'auth_database',
4024        'bind_interface',
4025        'connect_to_replica',
4026        'egress_filter',
4027        'healthy',
4028        'hostname',
4029        'id',
4030        'name',
4031        'password',
4032        'port_override',
4033        'replica_set',
4034        'secret_store_id',
4035        'tags',
4036        'username',
4037    ]
4038
4039    def __init__(
4040        self,
4041        auth_database=None,
4042        bind_interface=None,
4043        connect_to_replica=None,
4044        egress_filter=None,
4045        healthy=None,
4046        hostname=None,
4047        id=None,
4048        name=None,
4049        password=None,
4050        port_override=None,
4051        replica_set=None,
4052        secret_store_id=None,
4053        tags=None,
4054        username=None,
4055    ):
4056        self.auth_database = auth_database if auth_database is not None else ''
4057        self.bind_interface = bind_interface if bind_interface is not None else ''
4058        '''
4059         Bind interface
4060        '''
4061        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4062        self.egress_filter = egress_filter if egress_filter is not None else ''
4063        '''
4064         A filter applied to the routing logic to pin datasource to nodes.
4065        '''
4066        self.healthy = healthy if healthy is not None else False
4067        '''
4068         True if the datasource is reachable and the credentials are valid.
4069        '''
4070        self.hostname = hostname if hostname is not None else ''
4071        '''
4072         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4073        '''
4074        self.id = id if id is not None else ''
4075        '''
4076         Unique identifier of the Resource.
4077        '''
4078        self.name = name if name is not None else ''
4079        '''
4080         Unique human-readable name of the Resource.
4081        '''
4082        self.password = password if password is not None else ''
4083        self.port_override = port_override if port_override is not None else 0
4084        self.replica_set = replica_set if replica_set is not None else ''
4085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4086        '''
4087         ID of the secret store containing credentials for this resource, if any.
4088        '''
4089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4090        '''
4091         Tags is a map of key, value pairs.
4092        '''
4093        self.username = username if username is not None else ''
4094
4095    def __repr__(self):
4096        return '<sdm.DocumentDBReplicaSet ' + \
4097            'auth_database: ' + repr(self.auth_database) + ' ' +\
4098            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4099            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4100            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4101            'healthy: ' + repr(self.healthy) + ' ' +\
4102            'hostname: ' + repr(self.hostname) + ' ' +\
4103            'id: ' + repr(self.id) + ' ' +\
4104            'name: ' + repr(self.name) + ' ' +\
4105            'password: ' + repr(self.password) + ' ' +\
4106            'port_override: ' + repr(self.port_override) + ' ' +\
4107            'replica_set: ' + repr(self.replica_set) + ' ' +\
4108            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4109            'tags: ' + repr(self.tags) + ' ' +\
4110            'username: ' + repr(self.username) + ' ' +\
4111            '>'
4112
4113    def to_dict(self):
4114        return {
4115            'auth_database': self.auth_database,
4116            'bind_interface': self.bind_interface,
4117            'connect_to_replica': self.connect_to_replica,
4118            'egress_filter': self.egress_filter,
4119            'healthy': self.healthy,
4120            'hostname': self.hostname,
4121            'id': self.id,
4122            'name': self.name,
4123            'password': self.password,
4124            'port_override': self.port_override,
4125            'replica_set': self.replica_set,
4126            'secret_store_id': self.secret_store_id,
4127            'tags': self.tags,
4128            'username': self.username,
4129        }
4130
4131    @classmethod
4132    def from_dict(cls, d):
4133        return cls(
4134            auth_database=d.get('auth_database'),
4135            bind_interface=d.get('bind_interface'),
4136            connect_to_replica=d.get('connect_to_replica'),
4137            egress_filter=d.get('egress_filter'),
4138            healthy=d.get('healthy'),
4139            hostname=d.get('hostname'),
4140            id=d.get('id'),
4141            name=d.get('name'),
4142            password=d.get('password'),
4143            port_override=d.get('port_override'),
4144            replica_set=d.get('replica_set'),
4145            secret_store_id=d.get('secret_store_id'),
4146            tags=d.get('tags'),
4147            username=d.get('username'),
4148        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4039    def __init__(
4040        self,
4041        auth_database=None,
4042        bind_interface=None,
4043        connect_to_replica=None,
4044        egress_filter=None,
4045        healthy=None,
4046        hostname=None,
4047        id=None,
4048        name=None,
4049        password=None,
4050        port_override=None,
4051        replica_set=None,
4052        secret_store_id=None,
4053        tags=None,
4054        username=None,
4055    ):
4056        self.auth_database = auth_database if auth_database is not None else ''
4057        self.bind_interface = bind_interface if bind_interface is not None else ''
4058        '''
4059         Bind interface
4060        '''
4061        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4062        self.egress_filter = egress_filter if egress_filter is not None else ''
4063        '''
4064         A filter applied to the routing logic to pin datasource to nodes.
4065        '''
4066        self.healthy = healthy if healthy is not None else False
4067        '''
4068         True if the datasource is reachable and the credentials are valid.
4069        '''
4070        self.hostname = hostname if hostname is not None else ''
4071        '''
4072         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4073        '''
4074        self.id = id if id is not None else ''
4075        '''
4076         Unique identifier of the Resource.
4077        '''
4078        self.name = name if name is not None else ''
4079        '''
4080         Unique human-readable name of the Resource.
4081        '''
4082        self.password = password if password is not None else ''
4083        self.port_override = port_override if port_override is not None else 0
4084        self.replica_set = replica_set if replica_set is not None else ''
4085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4086        '''
4087         ID of the secret store containing credentials for this resource, if any.
4088        '''
4089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4090        '''
4091         Tags is a map of key, value pairs.
4092        '''
4093        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4113    def to_dict(self):
4114        return {
4115            'auth_database': self.auth_database,
4116            'bind_interface': self.bind_interface,
4117            'connect_to_replica': self.connect_to_replica,
4118            'egress_filter': self.egress_filter,
4119            'healthy': self.healthy,
4120            'hostname': self.hostname,
4121            'id': self.id,
4122            'name': self.name,
4123            'password': self.password,
4124            'port_override': self.port_override,
4125            'replica_set': self.replica_set,
4126            'secret_store_id': self.secret_store_id,
4127            'tags': self.tags,
4128            'username': self.username,
4129        }
@classmethod
def from_dict(cls, d)
4131    @classmethod
4132    def from_dict(cls, d):
4133        return cls(
4134            auth_database=d.get('auth_database'),
4135            bind_interface=d.get('bind_interface'),
4136            connect_to_replica=d.get('connect_to_replica'),
4137            egress_filter=d.get('egress_filter'),
4138            healthy=d.get('healthy'),
4139            hostname=d.get('hostname'),
4140            id=d.get('id'),
4141            name=d.get('name'),
4142            password=d.get('password'),
4143            port_override=d.get('port_override'),
4144            replica_set=d.get('replica_set'),
4145            secret_store_id=d.get('secret_store_id'),
4146            tags=d.get('tags'),
4147            username=d.get('username'),
4148        )
class Druid:
4151class Druid:
4152    __slots__ = [
4153        'bind_interface',
4154        'egress_filter',
4155        'healthy',
4156        'hostname',
4157        'id',
4158        'name',
4159        'password',
4160        'port',
4161        'port_override',
4162        'secret_store_id',
4163        'tags',
4164        'username',
4165    ]
4166
4167    def __init__(
4168        self,
4169        bind_interface=None,
4170        egress_filter=None,
4171        healthy=None,
4172        hostname=None,
4173        id=None,
4174        name=None,
4175        password=None,
4176        port=None,
4177        port_override=None,
4178        secret_store_id=None,
4179        tags=None,
4180        username=None,
4181    ):
4182        self.bind_interface = bind_interface if bind_interface is not None else ''
4183        '''
4184         Bind interface
4185        '''
4186        self.egress_filter = egress_filter if egress_filter is not None else ''
4187        '''
4188         A filter applied to the routing logic to pin datasource to nodes.
4189        '''
4190        self.healthy = healthy if healthy is not None else False
4191        '''
4192         True if the datasource is reachable and the credentials are valid.
4193        '''
4194        self.hostname = hostname if hostname is not None else ''
4195        self.id = id if id is not None else ''
4196        '''
4197         Unique identifier of the Resource.
4198        '''
4199        self.name = name if name is not None else ''
4200        '''
4201         Unique human-readable name of the Resource.
4202        '''
4203        self.password = password if password is not None else ''
4204        self.port = port if port is not None else 0
4205        self.port_override = port_override if port_override is not None else 0
4206        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4207        '''
4208         ID of the secret store containing credentials for this resource, if any.
4209        '''
4210        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4211        '''
4212         Tags is a map of key, value pairs.
4213        '''
4214        self.username = username if username is not None else ''
4215
4216    def __repr__(self):
4217        return '<sdm.Druid ' + \
4218            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4219            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4220            'healthy: ' + repr(self.healthy) + ' ' +\
4221            'hostname: ' + repr(self.hostname) + ' ' +\
4222            'id: ' + repr(self.id) + ' ' +\
4223            'name: ' + repr(self.name) + ' ' +\
4224            'password: ' + repr(self.password) + ' ' +\
4225            'port: ' + repr(self.port) + ' ' +\
4226            'port_override: ' + repr(self.port_override) + ' ' +\
4227            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4228            'tags: ' + repr(self.tags) + ' ' +\
4229            'username: ' + repr(self.username) + ' ' +\
4230            '>'
4231
4232    def to_dict(self):
4233        return {
4234            'bind_interface': self.bind_interface,
4235            'egress_filter': self.egress_filter,
4236            'healthy': self.healthy,
4237            'hostname': self.hostname,
4238            'id': self.id,
4239            'name': self.name,
4240            'password': self.password,
4241            'port': self.port,
4242            'port_override': self.port_override,
4243            'secret_store_id': self.secret_store_id,
4244            'tags': self.tags,
4245            'username': self.username,
4246        }
4247
4248    @classmethod
4249    def from_dict(cls, d):
4250        return cls(
4251            bind_interface=d.get('bind_interface'),
4252            egress_filter=d.get('egress_filter'),
4253            healthy=d.get('healthy'),
4254            hostname=d.get('hostname'),
4255            id=d.get('id'),
4256            name=d.get('name'),
4257            password=d.get('password'),
4258            port=d.get('port'),
4259            port_override=d.get('port_override'),
4260            secret_store_id=d.get('secret_store_id'),
4261            tags=d.get('tags'),
4262            username=d.get('username'),
4263        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4167    def __init__(
4168        self,
4169        bind_interface=None,
4170        egress_filter=None,
4171        healthy=None,
4172        hostname=None,
4173        id=None,
4174        name=None,
4175        password=None,
4176        port=None,
4177        port_override=None,
4178        secret_store_id=None,
4179        tags=None,
4180        username=None,
4181    ):
4182        self.bind_interface = bind_interface if bind_interface is not None else ''
4183        '''
4184         Bind interface
4185        '''
4186        self.egress_filter = egress_filter if egress_filter is not None else ''
4187        '''
4188         A filter applied to the routing logic to pin datasource to nodes.
4189        '''
4190        self.healthy = healthy if healthy is not None else False
4191        '''
4192         True if the datasource is reachable and the credentials are valid.
4193        '''
4194        self.hostname = hostname if hostname is not None else ''
4195        self.id = id if id is not None else ''
4196        '''
4197         Unique identifier of the Resource.
4198        '''
4199        self.name = name if name is not None else ''
4200        '''
4201         Unique human-readable name of the Resource.
4202        '''
4203        self.password = password if password is not None else ''
4204        self.port = port if port is not None else 0
4205        self.port_override = port_override if port_override is not None else 0
4206        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4207        '''
4208         ID of the secret store containing credentials for this resource, if any.
4209        '''
4210        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4211        '''
4212         Tags is a map of key, value pairs.
4213        '''
4214        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4232    def to_dict(self):
4233        return {
4234            'bind_interface': self.bind_interface,
4235            'egress_filter': self.egress_filter,
4236            'healthy': self.healthy,
4237            'hostname': self.hostname,
4238            'id': self.id,
4239            'name': self.name,
4240            'password': self.password,
4241            'port': self.port,
4242            'port_override': self.port_override,
4243            'secret_store_id': self.secret_store_id,
4244            'tags': self.tags,
4245            'username': self.username,
4246        }
@classmethod
def from_dict(cls, d)
4248    @classmethod
4249    def from_dict(cls, d):
4250        return cls(
4251            bind_interface=d.get('bind_interface'),
4252            egress_filter=d.get('egress_filter'),
4253            healthy=d.get('healthy'),
4254            hostname=d.get('hostname'),
4255            id=d.get('id'),
4256            name=d.get('name'),
4257            password=d.get('password'),
4258            port=d.get('port'),
4259            port_override=d.get('port_override'),
4260            secret_store_id=d.get('secret_store_id'),
4261            tags=d.get('tags'),
4262            username=d.get('username'),
4263        )
class DynamoDB:
4266class DynamoDB:
4267    __slots__ = [
4268        'access_key',
4269        'bind_interface',
4270        'egress_filter',
4271        'endpoint',
4272        'healthy',
4273        'id',
4274        'name',
4275        'port_override',
4276        'region',
4277        'role_arn',
4278        'role_external_id',
4279        'secret_access_key',
4280        'secret_store_id',
4281        'tags',
4282    ]
4283
4284    def __init__(
4285        self,
4286        access_key=None,
4287        bind_interface=None,
4288        egress_filter=None,
4289        endpoint=None,
4290        healthy=None,
4291        id=None,
4292        name=None,
4293        port_override=None,
4294        region=None,
4295        role_arn=None,
4296        role_external_id=None,
4297        secret_access_key=None,
4298        secret_store_id=None,
4299        tags=None,
4300    ):
4301        self.access_key = access_key if access_key is not None else ''
4302        self.bind_interface = bind_interface if bind_interface is not None else ''
4303        '''
4304         Bind interface
4305        '''
4306        self.egress_filter = egress_filter if egress_filter is not None else ''
4307        '''
4308         A filter applied to the routing logic to pin datasource to nodes.
4309        '''
4310        self.endpoint = endpoint if endpoint is not None else ''
4311        self.healthy = healthy if healthy is not None else False
4312        '''
4313         True if the datasource is reachable and the credentials are valid.
4314        '''
4315        self.id = id if id is not None else ''
4316        '''
4317         Unique identifier of the Resource.
4318        '''
4319        self.name = name if name is not None else ''
4320        '''
4321         Unique human-readable name of the Resource.
4322        '''
4323        self.port_override = port_override if port_override is not None else 0
4324        self.region = region if region is not None else ''
4325        self.role_arn = role_arn if role_arn is not None else ''
4326        self.role_external_id = role_external_id if role_external_id is not None else ''
4327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4328        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4329        '''
4330         ID of the secret store containing credentials for this resource, if any.
4331        '''
4332        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4333        '''
4334         Tags is a map of key, value pairs.
4335        '''
4336
4337    def __repr__(self):
4338        return '<sdm.DynamoDB ' + \
4339            'access_key: ' + repr(self.access_key) + ' ' +\
4340            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4341            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4342            'endpoint: ' + repr(self.endpoint) + ' ' +\
4343            'healthy: ' + repr(self.healthy) + ' ' +\
4344            'id: ' + repr(self.id) + ' ' +\
4345            'name: ' + repr(self.name) + ' ' +\
4346            'port_override: ' + repr(self.port_override) + ' ' +\
4347            'region: ' + repr(self.region) + ' ' +\
4348            'role_arn: ' + repr(self.role_arn) + ' ' +\
4349            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4350            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4351            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4352            'tags: ' + repr(self.tags) + ' ' +\
4353            '>'
4354
4355    def to_dict(self):
4356        return {
4357            'access_key': self.access_key,
4358            'bind_interface': self.bind_interface,
4359            'egress_filter': self.egress_filter,
4360            'endpoint': self.endpoint,
4361            'healthy': self.healthy,
4362            'id': self.id,
4363            'name': self.name,
4364            'port_override': self.port_override,
4365            'region': self.region,
4366            'role_arn': self.role_arn,
4367            'role_external_id': self.role_external_id,
4368            'secret_access_key': self.secret_access_key,
4369            'secret_store_id': self.secret_store_id,
4370            'tags': self.tags,
4371        }
4372
4373    @classmethod
4374    def from_dict(cls, d):
4375        return cls(
4376            access_key=d.get('access_key'),
4377            bind_interface=d.get('bind_interface'),
4378            egress_filter=d.get('egress_filter'),
4379            endpoint=d.get('endpoint'),
4380            healthy=d.get('healthy'),
4381            id=d.get('id'),
4382            name=d.get('name'),
4383            port_override=d.get('port_override'),
4384            region=d.get('region'),
4385            role_arn=d.get('role_arn'),
4386            role_external_id=d.get('role_external_id'),
4387            secret_access_key=d.get('secret_access_key'),
4388            secret_store_id=d.get('secret_store_id'),
4389            tags=d.get('tags'),
4390        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4284    def __init__(
4285        self,
4286        access_key=None,
4287        bind_interface=None,
4288        egress_filter=None,
4289        endpoint=None,
4290        healthy=None,
4291        id=None,
4292        name=None,
4293        port_override=None,
4294        region=None,
4295        role_arn=None,
4296        role_external_id=None,
4297        secret_access_key=None,
4298        secret_store_id=None,
4299        tags=None,
4300    ):
4301        self.access_key = access_key if access_key is not None else ''
4302        self.bind_interface = bind_interface if bind_interface is not None else ''
4303        '''
4304         Bind interface
4305        '''
4306        self.egress_filter = egress_filter if egress_filter is not None else ''
4307        '''
4308         A filter applied to the routing logic to pin datasource to nodes.
4309        '''
4310        self.endpoint = endpoint if endpoint is not None else ''
4311        self.healthy = healthy if healthy is not None else False
4312        '''
4313         True if the datasource is reachable and the credentials are valid.
4314        '''
4315        self.id = id if id is not None else ''
4316        '''
4317         Unique identifier of the Resource.
4318        '''
4319        self.name = name if name is not None else ''
4320        '''
4321         Unique human-readable name of the Resource.
4322        '''
4323        self.port_override = port_override if port_override is not None else 0
4324        self.region = region if region is not None else ''
4325        self.role_arn = role_arn if role_arn is not None else ''
4326        self.role_external_id = role_external_id if role_external_id is not None else ''
4327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4328        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4329        '''
4330         ID of the secret store containing credentials for this resource, if any.
4331        '''
4332        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4333        '''
4334         Tags is a map of key, value pairs.
4335        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4355    def to_dict(self):
4356        return {
4357            'access_key': self.access_key,
4358            'bind_interface': self.bind_interface,
4359            'egress_filter': self.egress_filter,
4360            'endpoint': self.endpoint,
4361            'healthy': self.healthy,
4362            'id': self.id,
4363            'name': self.name,
4364            'port_override': self.port_override,
4365            'region': self.region,
4366            'role_arn': self.role_arn,
4367            'role_external_id': self.role_external_id,
4368            'secret_access_key': self.secret_access_key,
4369            'secret_store_id': self.secret_store_id,
4370            'tags': self.tags,
4371        }
@classmethod
def from_dict(cls, d)
4373    @classmethod
4374    def from_dict(cls, d):
4375        return cls(
4376            access_key=d.get('access_key'),
4377            bind_interface=d.get('bind_interface'),
4378            egress_filter=d.get('egress_filter'),
4379            endpoint=d.get('endpoint'),
4380            healthy=d.get('healthy'),
4381            id=d.get('id'),
4382            name=d.get('name'),
4383            port_override=d.get('port_override'),
4384            region=d.get('region'),
4385            role_arn=d.get('role_arn'),
4386            role_external_id=d.get('role_external_id'),
4387            secret_access_key=d.get('secret_access_key'),
4388            secret_store_id=d.get('secret_store_id'),
4389            tags=d.get('tags'),
4390        )
class Elastic:
4393class Elastic:
4394    __slots__ = [
4395        'bind_interface',
4396        'egress_filter',
4397        'healthy',
4398        'hostname',
4399        'id',
4400        'name',
4401        'password',
4402        'port',
4403        'port_override',
4404        'secret_store_id',
4405        'tags',
4406        'tls_required',
4407        'username',
4408    ]
4409
4410    def __init__(
4411        self,
4412        bind_interface=None,
4413        egress_filter=None,
4414        healthy=None,
4415        hostname=None,
4416        id=None,
4417        name=None,
4418        password=None,
4419        port=None,
4420        port_override=None,
4421        secret_store_id=None,
4422        tags=None,
4423        tls_required=None,
4424        username=None,
4425    ):
4426        self.bind_interface = bind_interface if bind_interface is not None else ''
4427        '''
4428         Bind interface
4429        '''
4430        self.egress_filter = egress_filter if egress_filter is not None else ''
4431        '''
4432         A filter applied to the routing logic to pin datasource to nodes.
4433        '''
4434        self.healthy = healthy if healthy is not None else False
4435        '''
4436         True if the datasource is reachable and the credentials are valid.
4437        '''
4438        self.hostname = hostname if hostname is not None else ''
4439        self.id = id if id is not None else ''
4440        '''
4441         Unique identifier of the Resource.
4442        '''
4443        self.name = name if name is not None else ''
4444        '''
4445         Unique human-readable name of the Resource.
4446        '''
4447        self.password = password if password is not None else ''
4448        self.port = port if port is not None else 0
4449        self.port_override = port_override if port_override is not None else 0
4450        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4451        '''
4452         ID of the secret store containing credentials for this resource, if any.
4453        '''
4454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4455        '''
4456         Tags is a map of key, value pairs.
4457        '''
4458        self.tls_required = tls_required if tls_required is not None else False
4459        self.username = username if username is not None else ''
4460
4461    def __repr__(self):
4462        return '<sdm.Elastic ' + \
4463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4464            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4465            'healthy: ' + repr(self.healthy) + ' ' +\
4466            'hostname: ' + repr(self.hostname) + ' ' +\
4467            'id: ' + repr(self.id) + ' ' +\
4468            'name: ' + repr(self.name) + ' ' +\
4469            'password: ' + repr(self.password) + ' ' +\
4470            'port: ' + repr(self.port) + ' ' +\
4471            'port_override: ' + repr(self.port_override) + ' ' +\
4472            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4473            'tags: ' + repr(self.tags) + ' ' +\
4474            'tls_required: ' + repr(self.tls_required) + ' ' +\
4475            'username: ' + repr(self.username) + ' ' +\
4476            '>'
4477
4478    def to_dict(self):
4479        return {
4480            'bind_interface': self.bind_interface,
4481            'egress_filter': self.egress_filter,
4482            'healthy': self.healthy,
4483            'hostname': self.hostname,
4484            'id': self.id,
4485            'name': self.name,
4486            'password': self.password,
4487            'port': self.port,
4488            'port_override': self.port_override,
4489            'secret_store_id': self.secret_store_id,
4490            'tags': self.tags,
4491            'tls_required': self.tls_required,
4492            'username': self.username,
4493        }
4494
4495    @classmethod
4496    def from_dict(cls, d):
4497        return cls(
4498            bind_interface=d.get('bind_interface'),
4499            egress_filter=d.get('egress_filter'),
4500            healthy=d.get('healthy'),
4501            hostname=d.get('hostname'),
4502            id=d.get('id'),
4503            name=d.get('name'),
4504            password=d.get('password'),
4505            port=d.get('port'),
4506            port_override=d.get('port_override'),
4507            secret_store_id=d.get('secret_store_id'),
4508            tags=d.get('tags'),
4509            tls_required=d.get('tls_required'),
4510            username=d.get('username'),
4511        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4410    def __init__(
4411        self,
4412        bind_interface=None,
4413        egress_filter=None,
4414        healthy=None,
4415        hostname=None,
4416        id=None,
4417        name=None,
4418        password=None,
4419        port=None,
4420        port_override=None,
4421        secret_store_id=None,
4422        tags=None,
4423        tls_required=None,
4424        username=None,
4425    ):
4426        self.bind_interface = bind_interface if bind_interface is not None else ''
4427        '''
4428         Bind interface
4429        '''
4430        self.egress_filter = egress_filter if egress_filter is not None else ''
4431        '''
4432         A filter applied to the routing logic to pin datasource to nodes.
4433        '''
4434        self.healthy = healthy if healthy is not None else False
4435        '''
4436         True if the datasource is reachable and the credentials are valid.
4437        '''
4438        self.hostname = hostname if hostname is not None else ''
4439        self.id = id if id is not None else ''
4440        '''
4441         Unique identifier of the Resource.
4442        '''
4443        self.name = name if name is not None else ''
4444        '''
4445         Unique human-readable name of the Resource.
4446        '''
4447        self.password = password if password is not None else ''
4448        self.port = port if port is not None else 0
4449        self.port_override = port_override if port_override is not None else 0
4450        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4451        '''
4452         ID of the secret store containing credentials for this resource, if any.
4453        '''
4454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4455        '''
4456         Tags is a map of key, value pairs.
4457        '''
4458        self.tls_required = tls_required if tls_required is not None else False
4459        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4478    def to_dict(self):
4479        return {
4480            'bind_interface': self.bind_interface,
4481            'egress_filter': self.egress_filter,
4482            'healthy': self.healthy,
4483            'hostname': self.hostname,
4484            'id': self.id,
4485            'name': self.name,
4486            'password': self.password,
4487            'port': self.port,
4488            'port_override': self.port_override,
4489            'secret_store_id': self.secret_store_id,
4490            'tags': self.tags,
4491            'tls_required': self.tls_required,
4492            'username': self.username,
4493        }
@classmethod
def from_dict(cls, d)
4495    @classmethod
4496    def from_dict(cls, d):
4497        return cls(
4498            bind_interface=d.get('bind_interface'),
4499            egress_filter=d.get('egress_filter'),
4500            healthy=d.get('healthy'),
4501            hostname=d.get('hostname'),
4502            id=d.get('id'),
4503            name=d.get('name'),
4504            password=d.get('password'),
4505            port=d.get('port'),
4506            port_override=d.get('port_override'),
4507            secret_store_id=d.get('secret_store_id'),
4508            tags=d.get('tags'),
4509            tls_required=d.get('tls_required'),
4510            username=d.get('username'),
4511        )
class ElasticacheRedis:
4514class ElasticacheRedis:
4515    __slots__ = [
4516        'bind_interface',
4517        'egress_filter',
4518        'healthy',
4519        'hostname',
4520        'id',
4521        'name',
4522        'password',
4523        'port',
4524        'port_override',
4525        'secret_store_id',
4526        'tags',
4527        'tls_required',
4528    ]
4529
4530    def __init__(
4531        self,
4532        bind_interface=None,
4533        egress_filter=None,
4534        healthy=None,
4535        hostname=None,
4536        id=None,
4537        name=None,
4538        password=None,
4539        port=None,
4540        port_override=None,
4541        secret_store_id=None,
4542        tags=None,
4543        tls_required=None,
4544    ):
4545        self.bind_interface = bind_interface if bind_interface is not None else ''
4546        '''
4547         Bind interface
4548        '''
4549        self.egress_filter = egress_filter if egress_filter is not None else ''
4550        '''
4551         A filter applied to the routing logic to pin datasource to nodes.
4552        '''
4553        self.healthy = healthy if healthy is not None else False
4554        '''
4555         True if the datasource is reachable and the credentials are valid.
4556        '''
4557        self.hostname = hostname if hostname is not None else ''
4558        self.id = id if id is not None else ''
4559        '''
4560         Unique identifier of the Resource.
4561        '''
4562        self.name = name if name is not None else ''
4563        '''
4564         Unique human-readable name of the Resource.
4565        '''
4566        self.password = password if password is not None else ''
4567        self.port = port if port is not None else 0
4568        self.port_override = port_override if port_override is not None else 0
4569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4570        '''
4571         ID of the secret store containing credentials for this resource, if any.
4572        '''
4573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4574        '''
4575         Tags is a map of key, value pairs.
4576        '''
4577        self.tls_required = tls_required if tls_required is not None else False
4578
4579    def __repr__(self):
4580        return '<sdm.ElasticacheRedis ' + \
4581            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4582            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4583            'healthy: ' + repr(self.healthy) + ' ' +\
4584            'hostname: ' + repr(self.hostname) + ' ' +\
4585            'id: ' + repr(self.id) + ' ' +\
4586            'name: ' + repr(self.name) + ' ' +\
4587            'password: ' + repr(self.password) + ' ' +\
4588            'port: ' + repr(self.port) + ' ' +\
4589            'port_override: ' + repr(self.port_override) + ' ' +\
4590            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4591            'tags: ' + repr(self.tags) + ' ' +\
4592            'tls_required: ' + repr(self.tls_required) + ' ' +\
4593            '>'
4594
4595    def to_dict(self):
4596        return {
4597            'bind_interface': self.bind_interface,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port': self.port,
4605            'port_override': self.port_override,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'tls_required': self.tls_required,
4609        }
4610
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            bind_interface=d.get('bind_interface'),
4615            egress_filter=d.get('egress_filter'),
4616            healthy=d.get('healthy'),
4617            hostname=d.get('hostname'),
4618            id=d.get('id'),
4619            name=d.get('name'),
4620            password=d.get('password'),
4621            port=d.get('port'),
4622            port_override=d.get('port_override'),
4623            secret_store_id=d.get('secret_store_id'),
4624            tags=d.get('tags'),
4625            tls_required=d.get('tls_required'),
4626        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
4530    def __init__(
4531        self,
4532        bind_interface=None,
4533        egress_filter=None,
4534        healthy=None,
4535        hostname=None,
4536        id=None,
4537        name=None,
4538        password=None,
4539        port=None,
4540        port_override=None,
4541        secret_store_id=None,
4542        tags=None,
4543        tls_required=None,
4544    ):
4545        self.bind_interface = bind_interface if bind_interface is not None else ''
4546        '''
4547         Bind interface
4548        '''
4549        self.egress_filter = egress_filter if egress_filter is not None else ''
4550        '''
4551         A filter applied to the routing logic to pin datasource to nodes.
4552        '''
4553        self.healthy = healthy if healthy is not None else False
4554        '''
4555         True if the datasource is reachable and the credentials are valid.
4556        '''
4557        self.hostname = hostname if hostname is not None else ''
4558        self.id = id if id is not None else ''
4559        '''
4560         Unique identifier of the Resource.
4561        '''
4562        self.name = name if name is not None else ''
4563        '''
4564         Unique human-readable name of the Resource.
4565        '''
4566        self.password = password if password is not None else ''
4567        self.port = port if port is not None else 0
4568        self.port_override = port_override if port_override is not None else 0
4569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4570        '''
4571         ID of the secret store containing credentials for this resource, if any.
4572        '''
4573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4574        '''
4575         Tags is a map of key, value pairs.
4576        '''
4577        self.tls_required = tls_required if tls_required is not None else False
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
4595    def to_dict(self):
4596        return {
4597            'bind_interface': self.bind_interface,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port': self.port,
4605            'port_override': self.port_override,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'tls_required': self.tls_required,
4609        }
@classmethod
def from_dict(cls, d)
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            bind_interface=d.get('bind_interface'),
4615            egress_filter=d.get('egress_filter'),
4616            healthy=d.get('healthy'),
4617            hostname=d.get('hostname'),
4618            id=d.get('id'),
4619            name=d.get('name'),
4620            password=d.get('password'),
4621            port=d.get('port'),
4622            port_override=d.get('port_override'),
4623            secret_store_id=d.get('secret_store_id'),
4624            tags=d.get('tags'),
4625            tls_required=d.get('tls_required'),
4626        )
class EnvStore:
4629class EnvStore:
4630    '''
4631    EnvStore is currently unstable, and its API may change, or it may be removed,
4632    without a major version bump.
4633    '''
4634    __slots__ = [
4635        'id',
4636        'name',
4637        'tags',
4638    ]
4639
4640    def __init__(
4641        self,
4642        id=None,
4643        name=None,
4644        tags=None,
4645    ):
4646        self.id = id if id is not None else ''
4647        '''
4648         Unique identifier of the SecretStore.
4649        '''
4650        self.name = name if name is not None else ''
4651        '''
4652         Unique human-readable name of the SecretStore.
4653        '''
4654        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4655        '''
4656         Tags is a map of key, value pairs.
4657        '''
4658
4659    def __repr__(self):
4660        return '<sdm.EnvStore ' + \
4661            'id: ' + repr(self.id) + ' ' +\
4662            'name: ' + repr(self.name) + ' ' +\
4663            'tags: ' + repr(self.tags) + ' ' +\
4664            '>'
4665
4666    def to_dict(self):
4667        return {
4668            'id': self.id,
4669            'name': self.name,
4670            'tags': self.tags,
4671        }
4672
4673    @classmethod
4674    def from_dict(cls, d):
4675        return cls(
4676            id=d.get('id'),
4677            name=d.get('name'),
4678            tags=d.get('tags'),
4679        )

EnvStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

EnvStore(id=None, name=None, tags=None)
4640    def __init__(
4641        self,
4642        id=None,
4643        name=None,
4644        tags=None,
4645    ):
4646        self.id = id if id is not None else ''
4647        '''
4648         Unique identifier of the SecretStore.
4649        '''
4650        self.name = name if name is not None else ''
4651        '''
4652         Unique human-readable name of the SecretStore.
4653        '''
4654        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4655        '''
4656         Tags is a map of key, value pairs.
4657        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4666    def to_dict(self):
4667        return {
4668            'id': self.id,
4669            'name': self.name,
4670            'tags': self.tags,
4671        }
@classmethod
def from_dict(cls, d)
4673    @classmethod
4674    def from_dict(cls, d):
4675        return cls(
4676            id=d.get('id'),
4677            name=d.get('name'),
4678            tags=d.get('tags'),
4679        )
class GCP:
4682class GCP:
4683    __slots__ = [
4684        'bind_interface',
4685        'egress_filter',
4686        'healthy',
4687        'id',
4688        'keyfile',
4689        'name',
4690        'scopes',
4691        'secret_store_id',
4692        'tags',
4693    ]
4694
4695    def __init__(
4696        self,
4697        bind_interface=None,
4698        egress_filter=None,
4699        healthy=None,
4700        id=None,
4701        keyfile=None,
4702        name=None,
4703        scopes=None,
4704        secret_store_id=None,
4705        tags=None,
4706    ):
4707        self.bind_interface = bind_interface if bind_interface is not None else ''
4708        '''
4709         Bind interface
4710        '''
4711        self.egress_filter = egress_filter if egress_filter is not None else ''
4712        '''
4713         A filter applied to the routing logic to pin datasource to nodes.
4714        '''
4715        self.healthy = healthy if healthy is not None else False
4716        '''
4717         True if the datasource is reachable and the credentials are valid.
4718        '''
4719        self.id = id if id is not None else ''
4720        '''
4721         Unique identifier of the Resource.
4722        '''
4723        self.keyfile = keyfile if keyfile is not None else ''
4724        self.name = name if name is not None else ''
4725        '''
4726         Unique human-readable name of the Resource.
4727        '''
4728        self.scopes = scopes if scopes is not None else ''
4729        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4730        '''
4731         ID of the secret store containing credentials for this resource, if any.
4732        '''
4733        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4734        '''
4735         Tags is a map of key, value pairs.
4736        '''
4737
4738    def __repr__(self):
4739        return '<sdm.GCP ' + \
4740            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4741            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4742            'healthy: ' + repr(self.healthy) + ' ' +\
4743            'id: ' + repr(self.id) + ' ' +\
4744            'keyfile: ' + repr(self.keyfile) + ' ' +\
4745            'name: ' + repr(self.name) + ' ' +\
4746            'scopes: ' + repr(self.scopes) + ' ' +\
4747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4748            'tags: ' + repr(self.tags) + ' ' +\
4749            '>'
4750
4751    def to_dict(self):
4752        return {
4753            'bind_interface': self.bind_interface,
4754            'egress_filter': self.egress_filter,
4755            'healthy': self.healthy,
4756            'id': self.id,
4757            'keyfile': self.keyfile,
4758            'name': self.name,
4759            'scopes': self.scopes,
4760            'secret_store_id': self.secret_store_id,
4761            'tags': self.tags,
4762        }
4763
4764    @classmethod
4765    def from_dict(cls, d):
4766        return cls(
4767            bind_interface=d.get('bind_interface'),
4768            egress_filter=d.get('egress_filter'),
4769            healthy=d.get('healthy'),
4770            id=d.get('id'),
4771            keyfile=d.get('keyfile'),
4772            name=d.get('name'),
4773            scopes=d.get('scopes'),
4774            secret_store_id=d.get('secret_store_id'),
4775            tags=d.get('tags'),
4776        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
4695    def __init__(
4696        self,
4697        bind_interface=None,
4698        egress_filter=None,
4699        healthy=None,
4700        id=None,
4701        keyfile=None,
4702        name=None,
4703        scopes=None,
4704        secret_store_id=None,
4705        tags=None,
4706    ):
4707        self.bind_interface = bind_interface if bind_interface is not None else ''
4708        '''
4709         Bind interface
4710        '''
4711        self.egress_filter = egress_filter if egress_filter is not None else ''
4712        '''
4713         A filter applied to the routing logic to pin datasource to nodes.
4714        '''
4715        self.healthy = healthy if healthy is not None else False
4716        '''
4717         True if the datasource is reachable and the credentials are valid.
4718        '''
4719        self.id = id if id is not None else ''
4720        '''
4721         Unique identifier of the Resource.
4722        '''
4723        self.keyfile = keyfile if keyfile is not None else ''
4724        self.name = name if name is not None else ''
4725        '''
4726         Unique human-readable name of the Resource.
4727        '''
4728        self.scopes = scopes if scopes is not None else ''
4729        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4730        '''
4731         ID of the secret store containing credentials for this resource, if any.
4732        '''
4733        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4734        '''
4735         Tags is a map of key, value pairs.
4736        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4751    def to_dict(self):
4752        return {
4753            'bind_interface': self.bind_interface,
4754            'egress_filter': self.egress_filter,
4755            'healthy': self.healthy,
4756            'id': self.id,
4757            'keyfile': self.keyfile,
4758            'name': self.name,
4759            'scopes': self.scopes,
4760            'secret_store_id': self.secret_store_id,
4761            'tags': self.tags,
4762        }
@classmethod
def from_dict(cls, d)
4764    @classmethod
4765    def from_dict(cls, d):
4766        return cls(
4767            bind_interface=d.get('bind_interface'),
4768            egress_filter=d.get('egress_filter'),
4769            healthy=d.get('healthy'),
4770            id=d.get('id'),
4771            keyfile=d.get('keyfile'),
4772            name=d.get('name'),
4773            scopes=d.get('scopes'),
4774            secret_store_id=d.get('secret_store_id'),
4775            tags=d.get('tags'),
4776        )
class GCPStore:
4779class GCPStore:
4780    __slots__ = [
4781        'id',
4782        'name',
4783        'projectid',
4784        'tags',
4785    ]
4786
4787    def __init__(
4788        self,
4789        id=None,
4790        name=None,
4791        projectid=None,
4792        tags=None,
4793    ):
4794        self.id = id if id is not None else ''
4795        '''
4796         Unique identifier of the SecretStore.
4797        '''
4798        self.name = name if name is not None else ''
4799        '''
4800         Unique human-readable name of the SecretStore.
4801        '''
4802        self.projectid = projectid if projectid is not None else ''
4803        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4804        '''
4805         Tags is a map of key, value pairs.
4806        '''
4807
4808    def __repr__(self):
4809        return '<sdm.GCPStore ' + \
4810            'id: ' + repr(self.id) + ' ' +\
4811            'name: ' + repr(self.name) + ' ' +\
4812            'projectid: ' + repr(self.projectid) + ' ' +\
4813            'tags: ' + repr(self.tags) + ' ' +\
4814            '>'
4815
4816    def to_dict(self):
4817        return {
4818            'id': self.id,
4819            'name': self.name,
4820            'projectid': self.projectid,
4821            'tags': self.tags,
4822        }
4823
4824    @classmethod
4825    def from_dict(cls, d):
4826        return cls(
4827            id=d.get('id'),
4828            name=d.get('name'),
4829            projectid=d.get('projectid'),
4830            tags=d.get('tags'),
4831        )
GCPStore(id=None, name=None, projectid=None, tags=None)
4787    def __init__(
4788        self,
4789        id=None,
4790        name=None,
4791        projectid=None,
4792        tags=None,
4793    ):
4794        self.id = id if id is not None else ''
4795        '''
4796         Unique identifier of the SecretStore.
4797        '''
4798        self.name = name if name is not None else ''
4799        '''
4800         Unique human-readable name of the SecretStore.
4801        '''
4802        self.projectid = projectid if projectid is not None else ''
4803        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4804        '''
4805         Tags is a map of key, value pairs.
4806        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
4816    def to_dict(self):
4817        return {
4818            'id': self.id,
4819            'name': self.name,
4820            'projectid': self.projectid,
4821            'tags': self.tags,
4822        }
@classmethod
def from_dict(cls, d)
4824    @classmethod
4825    def from_dict(cls, d):
4826        return cls(
4827            id=d.get('id'),
4828            name=d.get('name'),
4829            projectid=d.get('projectid'),
4830            tags=d.get('tags'),
4831        )
class Gateway:
4834class Gateway:
4835    '''
4836         Gateway represents a StrongDM CLI installation running in gateway mode.
4837    '''
4838    __slots__ = [
4839        'bind_address',
4840        'gateway_filter',
4841        'id',
4842        'listen_address',
4843        'name',
4844        'state',
4845        'tags',
4846    ]
4847
4848    def __init__(
4849        self,
4850        bind_address=None,
4851        gateway_filter=None,
4852        id=None,
4853        listen_address=None,
4854        name=None,
4855        state=None,
4856        tags=None,
4857    ):
4858        self.bind_address = bind_address if bind_address is not None else ''
4859        '''
4860         The hostname/port tuple which the gateway daemon will bind to.
4861         If not provided on create, set to "0.0.0.0:listen_address_port".
4862        '''
4863        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4864        '''
4865         GatewayFilter can be used to restrict the peering between relays and
4866         gateways.
4867        '''
4868        self.id = id if id is not None else ''
4869        '''
4870         Unique identifier of the Gateway.
4871        '''
4872        self.listen_address = listen_address if listen_address is not None else ''
4873        '''
4874         The public hostname/port tuple at which the gateway will be accessible to clients.
4875        '''
4876        self.name = name if name is not None else ''
4877        '''
4878         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4879        '''
4880        self.state = state if state is not None else ''
4881        '''
4882         The current state of the gateway. One of: "new", "verifying_restart",
4883         "restarting", "started", "stopped", "dead", "unknown"
4884        '''
4885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4886        '''
4887         Tags is a map of key, value pairs.
4888        '''
4889
4890    def __repr__(self):
4891        return '<sdm.Gateway ' + \
4892            'bind_address: ' + repr(self.bind_address) + ' ' +\
4893            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
4894            'id: ' + repr(self.id) + ' ' +\
4895            'listen_address: ' + repr(self.listen_address) + ' ' +\
4896            'name: ' + repr(self.name) + ' ' +\
4897            'state: ' + repr(self.state) + ' ' +\
4898            'tags: ' + repr(self.tags) + ' ' +\
4899            '>'
4900
4901    def to_dict(self):
4902        return {
4903            'bind_address': self.bind_address,
4904            'gateway_filter': self.gateway_filter,
4905            'id': self.id,
4906            'listen_address': self.listen_address,
4907            'name': self.name,
4908            'state': self.state,
4909            'tags': self.tags,
4910        }
4911
4912    @classmethod
4913    def from_dict(cls, d):
4914        return cls(
4915            bind_address=d.get('bind_address'),
4916            gateway_filter=d.get('gateway_filter'),
4917            id=d.get('id'),
4918            listen_address=d.get('listen_address'),
4919            name=d.get('name'),
4920            state=d.get('state'),
4921            tags=d.get('tags'),
4922        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
4848    def __init__(
4849        self,
4850        bind_address=None,
4851        gateway_filter=None,
4852        id=None,
4853        listen_address=None,
4854        name=None,
4855        state=None,
4856        tags=None,
4857    ):
4858        self.bind_address = bind_address if bind_address is not None else ''
4859        '''
4860         The hostname/port tuple which the gateway daemon will bind to.
4861         If not provided on create, set to "0.0.0.0:listen_address_port".
4862        '''
4863        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4864        '''
4865         GatewayFilter can be used to restrict the peering between relays and
4866         gateways.
4867        '''
4868        self.id = id if id is not None else ''
4869        '''
4870         Unique identifier of the Gateway.
4871        '''
4872        self.listen_address = listen_address if listen_address is not None else ''
4873        '''
4874         The public hostname/port tuple at which the gateway will be accessible to clients.
4875        '''
4876        self.name = name if name is not None else ''
4877        '''
4878         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4879        '''
4880        self.state = state if state is not None else ''
4881        '''
4882         The current state of the gateway. One of: "new", "verifying_restart",
4883         "restarting", "started", "stopped", "dead", "unknown"
4884        '''
4885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4886        '''
4887         Tags is a map of key, value pairs.
4888        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
4901    def to_dict(self):
4902        return {
4903            'bind_address': self.bind_address,
4904            'gateway_filter': self.gateway_filter,
4905            'id': self.id,
4906            'listen_address': self.listen_address,
4907            'name': self.name,
4908            'state': self.state,
4909            'tags': self.tags,
4910        }
@classmethod
def from_dict(cls, d)
4912    @classmethod
4913    def from_dict(cls, d):
4914        return cls(
4915            bind_address=d.get('bind_address'),
4916            gateway_filter=d.get('gateway_filter'),
4917            id=d.get('id'),
4918            listen_address=d.get('listen_address'),
4919            name=d.get('name'),
4920            state=d.get('state'),
4921            tags=d.get('tags'),
4922        )
class GetResponseMetadata:
4925class GetResponseMetadata:
4926    '''
4927         GetResponseMetadata is reserved for future use.
4928    '''
4929    __slots__ = []
4930
4931    def __init__(self, ):
4932        pass
4933
4934    def __repr__(self):
4935        return '<sdm.GetResponseMetadata ' + \
4936            '>'
4937
4938    def to_dict(self):
4939        return {}
4940
4941    @classmethod
4942    def from_dict(cls, d):
4943        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
4931    def __init__(self, ):
4932        pass
def to_dict(self)
4938    def to_dict(self):
4939        return {}
@classmethod
def from_dict(cls, d)
4941    @classmethod
4942    def from_dict(cls, d):
4943        return cls()
class GoogleGKE:
4946class GoogleGKE:
4947    __slots__ = [
4948        'bind_interface',
4949        'certificate_authority',
4950        'egress_filter',
4951        'endpoint',
4952        'healthcheck_namespace',
4953        'healthy',
4954        'id',
4955        'name',
4956        'remote_identity_group_id',
4957        'remote_identity_healthcheck_username',
4958        'secret_store_id',
4959        'service_account_key',
4960        'tags',
4961    ]
4962
4963    def __init__(
4964        self,
4965        bind_interface=None,
4966        certificate_authority=None,
4967        egress_filter=None,
4968        endpoint=None,
4969        healthcheck_namespace=None,
4970        healthy=None,
4971        id=None,
4972        name=None,
4973        remote_identity_group_id=None,
4974        remote_identity_healthcheck_username=None,
4975        secret_store_id=None,
4976        service_account_key=None,
4977        tags=None,
4978    ):
4979        self.bind_interface = bind_interface if bind_interface is not None else ''
4980        '''
4981         Bind interface
4982        '''
4983        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
4984        self.egress_filter = egress_filter if egress_filter is not None else ''
4985        '''
4986         A filter applied to the routing logic to pin datasource to nodes.
4987        '''
4988        self.endpoint = endpoint if endpoint is not None else ''
4989        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
4990        '''
4991         The path used to check the health of your connection.  Defaults to `default`.
4992        '''
4993        self.healthy = healthy if healthy is not None else False
4994        '''
4995         True if the datasource is reachable and the credentials are valid.
4996        '''
4997        self.id = id if id is not None else ''
4998        '''
4999         Unique identifier of the Resource.
5000        '''
5001        self.name = name if name is not None else ''
5002        '''
5003         Unique human-readable name of the Resource.
5004        '''
5005        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5006        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5008        '''
5009         ID of the secret store containing credentials for this resource, if any.
5010        '''
5011        self.service_account_key = service_account_key if service_account_key is not None else ''
5012        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5013        '''
5014         Tags is a map of key, value pairs.
5015        '''
5016
5017    def __repr__(self):
5018        return '<sdm.GoogleGKE ' + \
5019            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5020            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5021            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5022            'endpoint: ' + repr(self.endpoint) + ' ' +\
5023            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5024            'healthy: ' + repr(self.healthy) + ' ' +\
5025            'id: ' + repr(self.id) + ' ' +\
5026            'name: ' + repr(self.name) + ' ' +\
5027            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5028            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5030            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5031            'tags: ' + repr(self.tags) + ' ' +\
5032            '>'
5033
5034    def to_dict(self):
5035        return {
5036            'bind_interface': self.bind_interface,
5037            'certificate_authority': self.certificate_authority,
5038            'egress_filter': self.egress_filter,
5039            'endpoint': self.endpoint,
5040            'healthcheck_namespace': self.healthcheck_namespace,
5041            'healthy': self.healthy,
5042            'id': self.id,
5043            'name': self.name,
5044            'remote_identity_group_id': self.remote_identity_group_id,
5045            'remote_identity_healthcheck_username':
5046            self.remote_identity_healthcheck_username,
5047            'secret_store_id': self.secret_store_id,
5048            'service_account_key': self.service_account_key,
5049            'tags': self.tags,
5050        }
5051
5052    @classmethod
5053    def from_dict(cls, d):
5054        return cls(
5055            bind_interface=d.get('bind_interface'),
5056            certificate_authority=d.get('certificate_authority'),
5057            egress_filter=d.get('egress_filter'),
5058            endpoint=d.get('endpoint'),
5059            healthcheck_namespace=d.get('healthcheck_namespace'),
5060            healthy=d.get('healthy'),
5061            id=d.get('id'),
5062            name=d.get('name'),
5063            remote_identity_group_id=d.get('remote_identity_group_id'),
5064            remote_identity_healthcheck_username=d.get(
5065                'remote_identity_healthcheck_username'),
5066            secret_store_id=d.get('secret_store_id'),
5067            service_account_key=d.get('service_account_key'),
5068            tags=d.get('tags'),
5069        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
4963    def __init__(
4964        self,
4965        bind_interface=None,
4966        certificate_authority=None,
4967        egress_filter=None,
4968        endpoint=None,
4969        healthcheck_namespace=None,
4970        healthy=None,
4971        id=None,
4972        name=None,
4973        remote_identity_group_id=None,
4974        remote_identity_healthcheck_username=None,
4975        secret_store_id=None,
4976        service_account_key=None,
4977        tags=None,
4978    ):
4979        self.bind_interface = bind_interface if bind_interface is not None else ''
4980        '''
4981         Bind interface
4982        '''
4983        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
4984        self.egress_filter = egress_filter if egress_filter is not None else ''
4985        '''
4986         A filter applied to the routing logic to pin datasource to nodes.
4987        '''
4988        self.endpoint = endpoint if endpoint is not None else ''
4989        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
4990        '''
4991         The path used to check the health of your connection.  Defaults to `default`.
4992        '''
4993        self.healthy = healthy if healthy is not None else False
4994        '''
4995         True if the datasource is reachable and the credentials are valid.
4996        '''
4997        self.id = id if id is not None else ''
4998        '''
4999         Unique identifier of the Resource.
5000        '''
5001        self.name = name if name is not None else ''
5002        '''
5003         Unique human-readable name of the Resource.
5004        '''
5005        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5006        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5008        '''
5009         ID of the secret store containing credentials for this resource, if any.
5010        '''
5011        self.service_account_key = service_account_key if service_account_key is not None else ''
5012        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5013        '''
5014         Tags is a map of key, value pairs.
5015        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5034    def to_dict(self):
5035        return {
5036            'bind_interface': self.bind_interface,
5037            'certificate_authority': self.certificate_authority,
5038            'egress_filter': self.egress_filter,
5039            'endpoint': self.endpoint,
5040            'healthcheck_namespace': self.healthcheck_namespace,
5041            'healthy': self.healthy,
5042            'id': self.id,
5043            'name': self.name,
5044            'remote_identity_group_id': self.remote_identity_group_id,
5045            'remote_identity_healthcheck_username':
5046            self.remote_identity_healthcheck_username,
5047            'secret_store_id': self.secret_store_id,
5048            'service_account_key': self.service_account_key,
5049            'tags': self.tags,
5050        }
@classmethod
def from_dict(cls, d)
5052    @classmethod
5053    def from_dict(cls, d):
5054        return cls(
5055            bind_interface=d.get('bind_interface'),
5056            certificate_authority=d.get('certificate_authority'),
5057            egress_filter=d.get('egress_filter'),
5058            endpoint=d.get('endpoint'),
5059            healthcheck_namespace=d.get('healthcheck_namespace'),
5060            healthy=d.get('healthy'),
5061            id=d.get('id'),
5062            name=d.get('name'),
5063            remote_identity_group_id=d.get('remote_identity_group_id'),
5064            remote_identity_healthcheck_username=d.get(
5065                'remote_identity_healthcheck_username'),
5066            secret_store_id=d.get('secret_store_id'),
5067            service_account_key=d.get('service_account_key'),
5068            tags=d.get('tags'),
5069        )
class GoogleGKEUserImpersonation:
5072class GoogleGKEUserImpersonation:
5073    __slots__ = [
5074        'bind_interface',
5075        'certificate_authority',
5076        'egress_filter',
5077        'endpoint',
5078        'healthcheck_namespace',
5079        'healthy',
5080        'id',
5081        'name',
5082        'secret_store_id',
5083        'service_account_key',
5084        'tags',
5085    ]
5086
5087    def __init__(
5088        self,
5089        bind_interface=None,
5090        certificate_authority=None,
5091        egress_filter=None,
5092        endpoint=None,
5093        healthcheck_namespace=None,
5094        healthy=None,
5095        id=None,
5096        name=None,
5097        secret_store_id=None,
5098        service_account_key=None,
5099        tags=None,
5100    ):
5101        self.bind_interface = bind_interface if bind_interface is not None else ''
5102        '''
5103         Bind interface
5104        '''
5105        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5106        self.egress_filter = egress_filter if egress_filter is not None else ''
5107        '''
5108         A filter applied to the routing logic to pin datasource to nodes.
5109        '''
5110        self.endpoint = endpoint if endpoint is not None else ''
5111        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5112        '''
5113         The path used to check the health of your connection.  Defaults to `default`.
5114        '''
5115        self.healthy = healthy if healthy is not None else False
5116        '''
5117         True if the datasource is reachable and the credentials are valid.
5118        '''
5119        self.id = id if id is not None else ''
5120        '''
5121         Unique identifier of the Resource.
5122        '''
5123        self.name = name if name is not None else ''
5124        '''
5125         Unique human-readable name of the Resource.
5126        '''
5127        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5128        '''
5129         ID of the secret store containing credentials for this resource, if any.
5130        '''
5131        self.service_account_key = service_account_key if service_account_key is not None else ''
5132        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5133        '''
5134         Tags is a map of key, value pairs.
5135        '''
5136
5137    def __repr__(self):
5138        return '<sdm.GoogleGKEUserImpersonation ' + \
5139            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5140            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5141            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5142            'endpoint: ' + repr(self.endpoint) + ' ' +\
5143            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5144            'healthy: ' + repr(self.healthy) + ' ' +\
5145            'id: ' + repr(self.id) + ' ' +\
5146            'name: ' + repr(self.name) + ' ' +\
5147            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5148            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5149            'tags: ' + repr(self.tags) + ' ' +\
5150            '>'
5151
5152    def to_dict(self):
5153        return {
5154            'bind_interface': self.bind_interface,
5155            'certificate_authority': self.certificate_authority,
5156            'egress_filter': self.egress_filter,
5157            'endpoint': self.endpoint,
5158            'healthcheck_namespace': self.healthcheck_namespace,
5159            'healthy': self.healthy,
5160            'id': self.id,
5161            'name': self.name,
5162            'secret_store_id': self.secret_store_id,
5163            'service_account_key': self.service_account_key,
5164            'tags': self.tags,
5165        }
5166
5167    @classmethod
5168    def from_dict(cls, d):
5169        return cls(
5170            bind_interface=d.get('bind_interface'),
5171            certificate_authority=d.get('certificate_authority'),
5172            egress_filter=d.get('egress_filter'),
5173            endpoint=d.get('endpoint'),
5174            healthcheck_namespace=d.get('healthcheck_namespace'),
5175            healthy=d.get('healthy'),
5176            id=d.get('id'),
5177            name=d.get('name'),
5178            secret_store_id=d.get('secret_store_id'),
5179            service_account_key=d.get('service_account_key'),
5180            tags=d.get('tags'),
5181        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5087    def __init__(
5088        self,
5089        bind_interface=None,
5090        certificate_authority=None,
5091        egress_filter=None,
5092        endpoint=None,
5093        healthcheck_namespace=None,
5094        healthy=None,
5095        id=None,
5096        name=None,
5097        secret_store_id=None,
5098        service_account_key=None,
5099        tags=None,
5100    ):
5101        self.bind_interface = bind_interface if bind_interface is not None else ''
5102        '''
5103         Bind interface
5104        '''
5105        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5106        self.egress_filter = egress_filter if egress_filter is not None else ''
5107        '''
5108         A filter applied to the routing logic to pin datasource to nodes.
5109        '''
5110        self.endpoint = endpoint if endpoint is not None else ''
5111        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5112        '''
5113         The path used to check the health of your connection.  Defaults to `default`.
5114        '''
5115        self.healthy = healthy if healthy is not None else False
5116        '''
5117         True if the datasource is reachable and the credentials are valid.
5118        '''
5119        self.id = id if id is not None else ''
5120        '''
5121         Unique identifier of the Resource.
5122        '''
5123        self.name = name if name is not None else ''
5124        '''
5125         Unique human-readable name of the Resource.
5126        '''
5127        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5128        '''
5129         ID of the secret store containing credentials for this resource, if any.
5130        '''
5131        self.service_account_key = service_account_key if service_account_key is not None else ''
5132        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5133        '''
5134         Tags is a map of key, value pairs.
5135        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5152    def to_dict(self):
5153        return {
5154            'bind_interface': self.bind_interface,
5155            'certificate_authority': self.certificate_authority,
5156            'egress_filter': self.egress_filter,
5157            'endpoint': self.endpoint,
5158            'healthcheck_namespace': self.healthcheck_namespace,
5159            'healthy': self.healthy,
5160            'id': self.id,
5161            'name': self.name,
5162            'secret_store_id': self.secret_store_id,
5163            'service_account_key': self.service_account_key,
5164            'tags': self.tags,
5165        }
@classmethod
def from_dict(cls, d)
5167    @classmethod
5168    def from_dict(cls, d):
5169        return cls(
5170            bind_interface=d.get('bind_interface'),
5171            certificate_authority=d.get('certificate_authority'),
5172            egress_filter=d.get('egress_filter'),
5173            endpoint=d.get('endpoint'),
5174            healthcheck_namespace=d.get('healthcheck_namespace'),
5175            healthy=d.get('healthy'),
5176            id=d.get('id'),
5177            name=d.get('name'),
5178            secret_store_id=d.get('secret_store_id'),
5179            service_account_key=d.get('service_account_key'),
5180            tags=d.get('tags'),
5181        )
class Greenplum:
5184class Greenplum:
5185    __slots__ = [
5186        'bind_interface',
5187        'database',
5188        'egress_filter',
5189        'healthy',
5190        'hostname',
5191        'id',
5192        'name',
5193        'override_database',
5194        'password',
5195        'port',
5196        'port_override',
5197        'secret_store_id',
5198        'tags',
5199        'username',
5200    ]
5201
5202    def __init__(
5203        self,
5204        bind_interface=None,
5205        database=None,
5206        egress_filter=None,
5207        healthy=None,
5208        hostname=None,
5209        id=None,
5210        name=None,
5211        override_database=None,
5212        password=None,
5213        port=None,
5214        port_override=None,
5215        secret_store_id=None,
5216        tags=None,
5217        username=None,
5218    ):
5219        self.bind_interface = bind_interface if bind_interface is not None else ''
5220        '''
5221         Bind interface
5222        '''
5223        self.database = database if database is not None else ''
5224        self.egress_filter = egress_filter if egress_filter is not None else ''
5225        '''
5226         A filter applied to the routing logic to pin datasource to nodes.
5227        '''
5228        self.healthy = healthy if healthy is not None else False
5229        '''
5230         True if the datasource is reachable and the credentials are valid.
5231        '''
5232        self.hostname = hostname if hostname is not None else ''
5233        self.id = id if id is not None else ''
5234        '''
5235         Unique identifier of the Resource.
5236        '''
5237        self.name = name if name is not None else ''
5238        '''
5239         Unique human-readable name of the Resource.
5240        '''
5241        self.override_database = override_database if override_database is not None else False
5242        self.password = password if password is not None else ''
5243        self.port = port if port is not None else 0
5244        self.port_override = port_override if port_override is not None else 0
5245        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5246        '''
5247         ID of the secret store containing credentials for this resource, if any.
5248        '''
5249        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5250        '''
5251         Tags is a map of key, value pairs.
5252        '''
5253        self.username = username if username is not None else ''
5254
5255    def __repr__(self):
5256        return '<sdm.Greenplum ' + \
5257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5258            'database: ' + repr(self.database) + ' ' +\
5259            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5260            'healthy: ' + repr(self.healthy) + ' ' +\
5261            'hostname: ' + repr(self.hostname) + ' ' +\
5262            'id: ' + repr(self.id) + ' ' +\
5263            'name: ' + repr(self.name) + ' ' +\
5264            'override_database: ' + repr(self.override_database) + ' ' +\
5265            'password: ' + repr(self.password) + ' ' +\
5266            'port: ' + repr(self.port) + ' ' +\
5267            'port_override: ' + repr(self.port_override) + ' ' +\
5268            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5269            'tags: ' + repr(self.tags) + ' ' +\
5270            'username: ' + repr(self.username) + ' ' +\
5271            '>'
5272
5273    def to_dict(self):
5274        return {
5275            'bind_interface': self.bind_interface,
5276            'database': self.database,
5277            'egress_filter': self.egress_filter,
5278            'healthy': self.healthy,
5279            'hostname': self.hostname,
5280            'id': self.id,
5281            'name': self.name,
5282            'override_database': self.override_database,
5283            'password': self.password,
5284            'port': self.port,
5285            'port_override': self.port_override,
5286            'secret_store_id': self.secret_store_id,
5287            'tags': self.tags,
5288            'username': self.username,
5289        }
5290
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            bind_interface=d.get('bind_interface'),
5295            database=d.get('database'),
5296            egress_filter=d.get('egress_filter'),
5297            healthy=d.get('healthy'),
5298            hostname=d.get('hostname'),
5299            id=d.get('id'),
5300            name=d.get('name'),
5301            override_database=d.get('override_database'),
5302            password=d.get('password'),
5303            port=d.get('port'),
5304            port_override=d.get('port_override'),
5305            secret_store_id=d.get('secret_store_id'),
5306            tags=d.get('tags'),
5307            username=d.get('username'),
5308        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5202    def __init__(
5203        self,
5204        bind_interface=None,
5205        database=None,
5206        egress_filter=None,
5207        healthy=None,
5208        hostname=None,
5209        id=None,
5210        name=None,
5211        override_database=None,
5212        password=None,
5213        port=None,
5214        port_override=None,
5215        secret_store_id=None,
5216        tags=None,
5217        username=None,
5218    ):
5219        self.bind_interface = bind_interface if bind_interface is not None else ''
5220        '''
5221         Bind interface
5222        '''
5223        self.database = database if database is not None else ''
5224        self.egress_filter = egress_filter if egress_filter is not None else ''
5225        '''
5226         A filter applied to the routing logic to pin datasource to nodes.
5227        '''
5228        self.healthy = healthy if healthy is not None else False
5229        '''
5230         True if the datasource is reachable and the credentials are valid.
5231        '''
5232        self.hostname = hostname if hostname is not None else ''
5233        self.id = id if id is not None else ''
5234        '''
5235         Unique identifier of the Resource.
5236        '''
5237        self.name = name if name is not None else ''
5238        '''
5239         Unique human-readable name of the Resource.
5240        '''
5241        self.override_database = override_database if override_database is not None else False
5242        self.password = password if password is not None else ''
5243        self.port = port if port is not None else 0
5244        self.port_override = port_override if port_override is not None else 0
5245        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5246        '''
5247         ID of the secret store containing credentials for this resource, if any.
5248        '''
5249        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5250        '''
5251         Tags is a map of key, value pairs.
5252        '''
5253        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5273    def to_dict(self):
5274        return {
5275            'bind_interface': self.bind_interface,
5276            'database': self.database,
5277            'egress_filter': self.egress_filter,
5278            'healthy': self.healthy,
5279            'hostname': self.hostname,
5280            'id': self.id,
5281            'name': self.name,
5282            'override_database': self.override_database,
5283            'password': self.password,
5284            'port': self.port,
5285            'port_override': self.port_override,
5286            'secret_store_id': self.secret_store_id,
5287            'tags': self.tags,
5288            'username': self.username,
5289        }
@classmethod
def from_dict(cls, d)
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            bind_interface=d.get('bind_interface'),
5295            database=d.get('database'),
5296            egress_filter=d.get('egress_filter'),
5297            healthy=d.get('healthy'),
5298            hostname=d.get('hostname'),
5299            id=d.get('id'),
5300            name=d.get('name'),
5301            override_database=d.get('override_database'),
5302            password=d.get('password'),
5303            port=d.get('port'),
5304            port_override=d.get('port_override'),
5305            secret_store_id=d.get('secret_store_id'),
5306            tags=d.get('tags'),
5307            username=d.get('username'),
5308        )
class HTTPAuth:
5311class HTTPAuth:
5312    __slots__ = [
5313        'auth_header',
5314        'bind_interface',
5315        'default_path',
5316        'egress_filter',
5317        'headers_blacklist',
5318        'healthcheck_path',
5319        'healthy',
5320        'id',
5321        'name',
5322        'secret_store_id',
5323        'subdomain',
5324        'tags',
5325        'url',
5326    ]
5327
5328    def __init__(
5329        self,
5330        auth_header=None,
5331        bind_interface=None,
5332        default_path=None,
5333        egress_filter=None,
5334        headers_blacklist=None,
5335        healthcheck_path=None,
5336        healthy=None,
5337        id=None,
5338        name=None,
5339        secret_store_id=None,
5340        subdomain=None,
5341        tags=None,
5342        url=None,
5343    ):
5344        self.auth_header = auth_header if auth_header is not None else ''
5345        self.bind_interface = bind_interface if bind_interface is not None else ''
5346        '''
5347         Bind interface
5348        '''
5349        self.default_path = default_path if default_path is not None else ''
5350        self.egress_filter = egress_filter if egress_filter is not None else ''
5351        '''
5352         A filter applied to the routing logic to pin datasource to nodes.
5353        '''
5354        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5355        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5356        self.healthy = healthy if healthy is not None else False
5357        '''
5358         True if the datasource is reachable and the credentials are valid.
5359        '''
5360        self.id = id if id is not None else ''
5361        '''
5362         Unique identifier of the Resource.
5363        '''
5364        self.name = name if name is not None else ''
5365        '''
5366         Unique human-readable name of the Resource.
5367        '''
5368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5369        '''
5370         ID of the secret store containing credentials for this resource, if any.
5371        '''
5372        self.subdomain = subdomain if subdomain is not None else ''
5373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5374        '''
5375         Tags is a map of key, value pairs.
5376        '''
5377        self.url = url if url is not None else ''
5378
5379    def __repr__(self):
5380        return '<sdm.HTTPAuth ' + \
5381            'auth_header: ' + repr(self.auth_header) + ' ' +\
5382            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5383            'default_path: ' + repr(self.default_path) + ' ' +\
5384            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5385            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5386            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5387            'healthy: ' + repr(self.healthy) + ' ' +\
5388            'id: ' + repr(self.id) + ' ' +\
5389            'name: ' + repr(self.name) + ' ' +\
5390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5391            'subdomain: ' + repr(self.subdomain) + ' ' +\
5392            'tags: ' + repr(self.tags) + ' ' +\
5393            'url: ' + repr(self.url) + ' ' +\
5394            '>'
5395
5396    def to_dict(self):
5397        return {
5398            'auth_header': self.auth_header,
5399            'bind_interface': self.bind_interface,
5400            'default_path': self.default_path,
5401            'egress_filter': self.egress_filter,
5402            'headers_blacklist': self.headers_blacklist,
5403            'healthcheck_path': self.healthcheck_path,
5404            'healthy': self.healthy,
5405            'id': self.id,
5406            'name': self.name,
5407            'secret_store_id': self.secret_store_id,
5408            'subdomain': self.subdomain,
5409            'tags': self.tags,
5410            'url': self.url,
5411        }
5412
5413    @classmethod
5414    def from_dict(cls, d):
5415        return cls(
5416            auth_header=d.get('auth_header'),
5417            bind_interface=d.get('bind_interface'),
5418            default_path=d.get('default_path'),
5419            egress_filter=d.get('egress_filter'),
5420            headers_blacklist=d.get('headers_blacklist'),
5421            healthcheck_path=d.get('healthcheck_path'),
5422            healthy=d.get('healthy'),
5423            id=d.get('id'),
5424            name=d.get('name'),
5425            secret_store_id=d.get('secret_store_id'),
5426            subdomain=d.get('subdomain'),
5427            tags=d.get('tags'),
5428            url=d.get('url'),
5429        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5328    def __init__(
5329        self,
5330        auth_header=None,
5331        bind_interface=None,
5332        default_path=None,
5333        egress_filter=None,
5334        headers_blacklist=None,
5335        healthcheck_path=None,
5336        healthy=None,
5337        id=None,
5338        name=None,
5339        secret_store_id=None,
5340        subdomain=None,
5341        tags=None,
5342        url=None,
5343    ):
5344        self.auth_header = auth_header if auth_header is not None else ''
5345        self.bind_interface = bind_interface if bind_interface is not None else ''
5346        '''
5347         Bind interface
5348        '''
5349        self.default_path = default_path if default_path is not None else ''
5350        self.egress_filter = egress_filter if egress_filter is not None else ''
5351        '''
5352         A filter applied to the routing logic to pin datasource to nodes.
5353        '''
5354        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5355        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5356        self.healthy = healthy if healthy is not None else False
5357        '''
5358         True if the datasource is reachable and the credentials are valid.
5359        '''
5360        self.id = id if id is not None else ''
5361        '''
5362         Unique identifier of the Resource.
5363        '''
5364        self.name = name if name is not None else ''
5365        '''
5366         Unique human-readable name of the Resource.
5367        '''
5368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5369        '''
5370         ID of the secret store containing credentials for this resource, if any.
5371        '''
5372        self.subdomain = subdomain if subdomain is not None else ''
5373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5374        '''
5375         Tags is a map of key, value pairs.
5376        '''
5377        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5396    def to_dict(self):
5397        return {
5398            'auth_header': self.auth_header,
5399            'bind_interface': self.bind_interface,
5400            'default_path': self.default_path,
5401            'egress_filter': self.egress_filter,
5402            'headers_blacklist': self.headers_blacklist,
5403            'healthcheck_path': self.healthcheck_path,
5404            'healthy': self.healthy,
5405            'id': self.id,
5406            'name': self.name,
5407            'secret_store_id': self.secret_store_id,
5408            'subdomain': self.subdomain,
5409            'tags': self.tags,
5410            'url': self.url,
5411        }
@classmethod
def from_dict(cls, d)
5413    @classmethod
5414    def from_dict(cls, d):
5415        return cls(
5416            auth_header=d.get('auth_header'),
5417            bind_interface=d.get('bind_interface'),
5418            default_path=d.get('default_path'),
5419            egress_filter=d.get('egress_filter'),
5420            headers_blacklist=d.get('headers_blacklist'),
5421            healthcheck_path=d.get('healthcheck_path'),
5422            healthy=d.get('healthy'),
5423            id=d.get('id'),
5424            name=d.get('name'),
5425            secret_store_id=d.get('secret_store_id'),
5426            subdomain=d.get('subdomain'),
5427            tags=d.get('tags'),
5428            url=d.get('url'),
5429        )
class HTTPBasicAuth:
5432class HTTPBasicAuth:
5433    __slots__ = [
5434        'bind_interface',
5435        'default_path',
5436        'egress_filter',
5437        'headers_blacklist',
5438        'healthcheck_path',
5439        'healthy',
5440        'id',
5441        'name',
5442        'password',
5443        'secret_store_id',
5444        'subdomain',
5445        'tags',
5446        'url',
5447        'username',
5448    ]
5449
5450    def __init__(
5451        self,
5452        bind_interface=None,
5453        default_path=None,
5454        egress_filter=None,
5455        headers_blacklist=None,
5456        healthcheck_path=None,
5457        healthy=None,
5458        id=None,
5459        name=None,
5460        password=None,
5461        secret_store_id=None,
5462        subdomain=None,
5463        tags=None,
5464        url=None,
5465        username=None,
5466    ):
5467        self.bind_interface = bind_interface if bind_interface is not None else ''
5468        '''
5469         Bind interface
5470        '''
5471        self.default_path = default_path if default_path is not None else ''
5472        self.egress_filter = egress_filter if egress_filter is not None else ''
5473        '''
5474         A filter applied to the routing logic to pin datasource to nodes.
5475        '''
5476        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5477        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5478        self.healthy = healthy if healthy is not None else False
5479        '''
5480         True if the datasource is reachable and the credentials are valid.
5481        '''
5482        self.id = id if id is not None else ''
5483        '''
5484         Unique identifier of the Resource.
5485        '''
5486        self.name = name if name is not None else ''
5487        '''
5488         Unique human-readable name of the Resource.
5489        '''
5490        self.password = password if password is not None else ''
5491        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5492        '''
5493         ID of the secret store containing credentials for this resource, if any.
5494        '''
5495        self.subdomain = subdomain if subdomain is not None else ''
5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5497        '''
5498         Tags is a map of key, value pairs.
5499        '''
5500        self.url = url if url is not None else ''
5501        self.username = username if username is not None else ''
5502
5503    def __repr__(self):
5504        return '<sdm.HTTPBasicAuth ' + \
5505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5506            'default_path: ' + repr(self.default_path) + ' ' +\
5507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5508            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5509            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5510            'healthy: ' + repr(self.healthy) + ' ' +\
5511            'id: ' + repr(self.id) + ' ' +\
5512            'name: ' + repr(self.name) + ' ' +\
5513            'password: ' + repr(self.password) + ' ' +\
5514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5515            'subdomain: ' + repr(self.subdomain) + ' ' +\
5516            'tags: ' + repr(self.tags) + ' ' +\
5517            'url: ' + repr(self.url) + ' ' +\
5518            'username: ' + repr(self.username) + ' ' +\
5519            '>'
5520
5521    def to_dict(self):
5522        return {
5523            'bind_interface': self.bind_interface,
5524            'default_path': self.default_path,
5525            'egress_filter': self.egress_filter,
5526            'headers_blacklist': self.headers_blacklist,
5527            'healthcheck_path': self.healthcheck_path,
5528            'healthy': self.healthy,
5529            'id': self.id,
5530            'name': self.name,
5531            'password': self.password,
5532            'secret_store_id': self.secret_store_id,
5533            'subdomain': self.subdomain,
5534            'tags': self.tags,
5535            'url': self.url,
5536            'username': self.username,
5537        }
5538
5539    @classmethod
5540    def from_dict(cls, d):
5541        return cls(
5542            bind_interface=d.get('bind_interface'),
5543            default_path=d.get('default_path'),
5544            egress_filter=d.get('egress_filter'),
5545            headers_blacklist=d.get('headers_blacklist'),
5546            healthcheck_path=d.get('healthcheck_path'),
5547            healthy=d.get('healthy'),
5548            id=d.get('id'),
5549            name=d.get('name'),
5550            password=d.get('password'),
5551            secret_store_id=d.get('secret_store_id'),
5552            subdomain=d.get('subdomain'),
5553            tags=d.get('tags'),
5554            url=d.get('url'),
5555            username=d.get('username'),
5556        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5450    def __init__(
5451        self,
5452        bind_interface=None,
5453        default_path=None,
5454        egress_filter=None,
5455        headers_blacklist=None,
5456        healthcheck_path=None,
5457        healthy=None,
5458        id=None,
5459        name=None,
5460        password=None,
5461        secret_store_id=None,
5462        subdomain=None,
5463        tags=None,
5464        url=None,
5465        username=None,
5466    ):
5467        self.bind_interface = bind_interface if bind_interface is not None else ''
5468        '''
5469         Bind interface
5470        '''
5471        self.default_path = default_path if default_path is not None else ''
5472        self.egress_filter = egress_filter if egress_filter is not None else ''
5473        '''
5474         A filter applied to the routing logic to pin datasource to nodes.
5475        '''
5476        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5477        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5478        self.healthy = healthy if healthy is not None else False
5479        '''
5480         True if the datasource is reachable and the credentials are valid.
5481        '''
5482        self.id = id if id is not None else ''
5483        '''
5484         Unique identifier of the Resource.
5485        '''
5486        self.name = name if name is not None else ''
5487        '''
5488         Unique human-readable name of the Resource.
5489        '''
5490        self.password = password if password is not None else ''
5491        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5492        '''
5493         ID of the secret store containing credentials for this resource, if any.
5494        '''
5495        self.subdomain = subdomain if subdomain is not None else ''
5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5497        '''
5498         Tags is a map of key, value pairs.
5499        '''
5500        self.url = url if url is not None else ''
5501        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
5521    def to_dict(self):
5522        return {
5523            'bind_interface': self.bind_interface,
5524            'default_path': self.default_path,
5525            'egress_filter': self.egress_filter,
5526            'headers_blacklist': self.headers_blacklist,
5527            'healthcheck_path': self.healthcheck_path,
5528            'healthy': self.healthy,
5529            'id': self.id,
5530            'name': self.name,
5531            'password': self.password,
5532            'secret_store_id': self.secret_store_id,
5533            'subdomain': self.subdomain,
5534            'tags': self.tags,
5535            'url': self.url,
5536            'username': self.username,
5537        }
@classmethod
def from_dict(cls, d)
5539    @classmethod
5540    def from_dict(cls, d):
5541        return cls(
5542            bind_interface=d.get('bind_interface'),
5543            default_path=d.get('default_path'),
5544            egress_filter=d.get('egress_filter'),
5545            headers_blacklist=d.get('headers_blacklist'),
5546            healthcheck_path=d.get('healthcheck_path'),
5547            healthy=d.get('healthy'),
5548            id=d.get('id'),
5549            name=d.get('name'),
5550            password=d.get('password'),
5551            secret_store_id=d.get('secret_store_id'),
5552            subdomain=d.get('subdomain'),
5553            tags=d.get('tags'),
5554            url=d.get('url'),
5555            username=d.get('username'),
5556        )
class HTTPNoAuth:
5559class HTTPNoAuth:
5560    __slots__ = [
5561        'bind_interface',
5562        'default_path',
5563        'egress_filter',
5564        'headers_blacklist',
5565        'healthcheck_path',
5566        'healthy',
5567        'id',
5568        'name',
5569        'secret_store_id',
5570        'subdomain',
5571        'tags',
5572        'url',
5573    ]
5574
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        default_path=None,
5579        egress_filter=None,
5580        headers_blacklist=None,
5581        healthcheck_path=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        subdomain=None,
5587        tags=None,
5588        url=None,
5589    ):
5590        self.bind_interface = bind_interface if bind_interface is not None else ''
5591        '''
5592         Bind interface
5593        '''
5594        self.default_path = default_path if default_path is not None else ''
5595        self.egress_filter = egress_filter if egress_filter is not None else ''
5596        '''
5597         A filter applied to the routing logic to pin datasource to nodes.
5598        '''
5599        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5600        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5601        self.healthy = healthy if healthy is not None else False
5602        '''
5603         True if the datasource is reachable and the credentials are valid.
5604        '''
5605        self.id = id if id is not None else ''
5606        '''
5607         Unique identifier of the Resource.
5608        '''
5609        self.name = name if name is not None else ''
5610        '''
5611         Unique human-readable name of the Resource.
5612        '''
5613        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5614        '''
5615         ID of the secret store containing credentials for this resource, if any.
5616        '''
5617        self.subdomain = subdomain if subdomain is not None else ''
5618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5619        '''
5620         Tags is a map of key, value pairs.
5621        '''
5622        self.url = url if url is not None else ''
5623
5624    def __repr__(self):
5625        return '<sdm.HTTPNoAuth ' + \
5626            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5627            'default_path: ' + repr(self.default_path) + ' ' +\
5628            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5629            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5630            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5631            'healthy: ' + repr(self.healthy) + ' ' +\
5632            'id: ' + repr(self.id) + ' ' +\
5633            'name: ' + repr(self.name) + ' ' +\
5634            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5635            'subdomain: ' + repr(self.subdomain) + ' ' +\
5636            'tags: ' + repr(self.tags) + ' ' +\
5637            'url: ' + repr(self.url) + ' ' +\
5638            '>'
5639
5640    def to_dict(self):
5641        return {
5642            'bind_interface': self.bind_interface,
5643            'default_path': self.default_path,
5644            'egress_filter': self.egress_filter,
5645            'headers_blacklist': self.headers_blacklist,
5646            'healthcheck_path': self.healthcheck_path,
5647            'healthy': self.healthy,
5648            'id': self.id,
5649            'name': self.name,
5650            'secret_store_id': self.secret_store_id,
5651            'subdomain': self.subdomain,
5652            'tags': self.tags,
5653            'url': self.url,
5654        }
5655
5656    @classmethod
5657    def from_dict(cls, d):
5658        return cls(
5659            bind_interface=d.get('bind_interface'),
5660            default_path=d.get('default_path'),
5661            egress_filter=d.get('egress_filter'),
5662            headers_blacklist=d.get('headers_blacklist'),
5663            healthcheck_path=d.get('healthcheck_path'),
5664            healthy=d.get('healthy'),
5665            id=d.get('id'),
5666            name=d.get('name'),
5667            secret_store_id=d.get('secret_store_id'),
5668            subdomain=d.get('subdomain'),
5669            tags=d.get('tags'),
5670            url=d.get('url'),
5671        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        default_path=None,
5579        egress_filter=None,
5580        headers_blacklist=None,
5581        healthcheck_path=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        subdomain=None,
5587        tags=None,
5588        url=None,
5589    ):
5590        self.bind_interface = bind_interface if bind_interface is not None else ''
5591        '''
5592         Bind interface
5593        '''
5594        self.default_path = default_path if default_path is not None else ''
5595        self.egress_filter = egress_filter if egress_filter is not None else ''
5596        '''
5597         A filter applied to the routing logic to pin datasource to nodes.
5598        '''
5599        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5600        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5601        self.healthy = healthy if healthy is not None else False
5602        '''
5603         True if the datasource is reachable and the credentials are valid.
5604        '''
5605        self.id = id if id is not None else ''
5606        '''
5607         Unique identifier of the Resource.
5608        '''
5609        self.name = name if name is not None else ''
5610        '''
5611         Unique human-readable name of the Resource.
5612        '''
5613        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5614        '''
5615         ID of the secret store containing credentials for this resource, if any.
5616        '''
5617        self.subdomain = subdomain if subdomain is not None else ''
5618        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5619        '''
5620         Tags is a map of key, value pairs.
5621        '''
5622        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5640    def to_dict(self):
5641        return {
5642            'bind_interface': self.bind_interface,
5643            'default_path': self.default_path,
5644            'egress_filter': self.egress_filter,
5645            'headers_blacklist': self.headers_blacklist,
5646            'healthcheck_path': self.healthcheck_path,
5647            'healthy': self.healthy,
5648            'id': self.id,
5649            'name': self.name,
5650            'secret_store_id': self.secret_store_id,
5651            'subdomain': self.subdomain,
5652            'tags': self.tags,
5653            'url': self.url,
5654        }
@classmethod
def from_dict(cls, d)
5656    @classmethod
5657    def from_dict(cls, d):
5658        return cls(
5659            bind_interface=d.get('bind_interface'),
5660            default_path=d.get('default_path'),
5661            egress_filter=d.get('egress_filter'),
5662            headers_blacklist=d.get('headers_blacklist'),
5663            healthcheck_path=d.get('healthcheck_path'),
5664            healthy=d.get('healthy'),
5665            id=d.get('id'),
5666            name=d.get('name'),
5667            secret_store_id=d.get('secret_store_id'),
5668            subdomain=d.get('subdomain'),
5669            tags=d.get('tags'),
5670            url=d.get('url'),
5671        )
class Kubernetes:
5674class Kubernetes:
5675    __slots__ = [
5676        'bind_interface',
5677        'certificate_authority',
5678        'client_certificate',
5679        'client_key',
5680        'egress_filter',
5681        'healthcheck_namespace',
5682        'healthy',
5683        'hostname',
5684        'id',
5685        'name',
5686        'port',
5687        'port_override',
5688        'remote_identity_group_id',
5689        'remote_identity_healthcheck_username',
5690        'secret_store_id',
5691        'tags',
5692    ]
5693
5694    def __init__(
5695        self,
5696        bind_interface=None,
5697        certificate_authority=None,
5698        client_certificate=None,
5699        client_key=None,
5700        egress_filter=None,
5701        healthcheck_namespace=None,
5702        healthy=None,
5703        hostname=None,
5704        id=None,
5705        name=None,
5706        port=None,
5707        port_override=None,
5708        remote_identity_group_id=None,
5709        remote_identity_healthcheck_username=None,
5710        secret_store_id=None,
5711        tags=None,
5712    ):
5713        self.bind_interface = bind_interface if bind_interface is not None else ''
5714        '''
5715         Bind interface
5716        '''
5717        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5718        self.client_certificate = client_certificate if client_certificate is not None else ''
5719        self.client_key = client_key if client_key is not None else ''
5720        self.egress_filter = egress_filter if egress_filter is not None else ''
5721        '''
5722         A filter applied to the routing logic to pin datasource to nodes.
5723        '''
5724        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5725        '''
5726         The path used to check the health of your connection.  Defaults to `default`.
5727        '''
5728        self.healthy = healthy if healthy is not None else False
5729        '''
5730         True if the datasource is reachable and the credentials are valid.
5731        '''
5732        self.hostname = hostname if hostname is not None else ''
5733        self.id = id if id is not None else ''
5734        '''
5735         Unique identifier of the Resource.
5736        '''
5737        self.name = name if name is not None else ''
5738        '''
5739         Unique human-readable name of the Resource.
5740        '''
5741        self.port = port if port is not None else 0
5742        self.port_override = port_override if port_override is not None else 0
5743        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5744        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5745        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5746        '''
5747         ID of the secret store containing credentials for this resource, if any.
5748        '''
5749        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5750        '''
5751         Tags is a map of key, value pairs.
5752        '''
5753
5754    def __repr__(self):
5755        return '<sdm.Kubernetes ' + \
5756            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5757            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5758            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
5759            'client_key: ' + repr(self.client_key) + ' ' +\
5760            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5761            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5762            'healthy: ' + repr(self.healthy) + ' ' +\
5763            'hostname: ' + repr(self.hostname) + ' ' +\
5764            'id: ' + repr(self.id) + ' ' +\
5765            'name: ' + repr(self.name) + ' ' +\
5766            'port: ' + repr(self.port) + ' ' +\
5767            'port_override: ' + repr(self.port_override) + ' ' +\
5768            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5769            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5770            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5771            'tags: ' + repr(self.tags) + ' ' +\
5772            '>'
5773
5774    def to_dict(self):
5775        return {
5776            'bind_interface': self.bind_interface,
5777            'certificate_authority': self.certificate_authority,
5778            'client_certificate': self.client_certificate,
5779            'client_key': self.client_key,
5780            'egress_filter': self.egress_filter,
5781            'healthcheck_namespace': self.healthcheck_namespace,
5782            'healthy': self.healthy,
5783            'hostname': self.hostname,
5784            'id': self.id,
5785            'name': self.name,
5786            'port': self.port,
5787            'port_override': self.port_override,
5788            'remote_identity_group_id': self.remote_identity_group_id,
5789            'remote_identity_healthcheck_username':
5790            self.remote_identity_healthcheck_username,
5791            'secret_store_id': self.secret_store_id,
5792            'tags': self.tags,
5793        }
5794
5795    @classmethod
5796    def from_dict(cls, d):
5797        return cls(
5798            bind_interface=d.get('bind_interface'),
5799            certificate_authority=d.get('certificate_authority'),
5800            client_certificate=d.get('client_certificate'),
5801            client_key=d.get('client_key'),
5802            egress_filter=d.get('egress_filter'),
5803            healthcheck_namespace=d.get('healthcheck_namespace'),
5804            healthy=d.get('healthy'),
5805            hostname=d.get('hostname'),
5806            id=d.get('id'),
5807            name=d.get('name'),
5808            port=d.get('port'),
5809            port_override=d.get('port_override'),
5810            remote_identity_group_id=d.get('remote_identity_group_id'),
5811            remote_identity_healthcheck_username=d.get(
5812                'remote_identity_healthcheck_username'),
5813            secret_store_id=d.get('secret_store_id'),
5814            tags=d.get('tags'),
5815        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
5694    def __init__(
5695        self,
5696        bind_interface=None,
5697        certificate_authority=None,
5698        client_certificate=None,
5699        client_key=None,
5700        egress_filter=None,
5701        healthcheck_namespace=None,
5702        healthy=None,
5703        hostname=None,
5704        id=None,
5705        name=None,
5706        port=None,
5707        port_override=None,
5708        remote_identity_group_id=None,
5709        remote_identity_healthcheck_username=None,
5710        secret_store_id=None,
5711        tags=None,
5712    ):
5713        self.bind_interface = bind_interface if bind_interface is not None else ''
5714        '''
5715         Bind interface
5716        '''
5717        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5718        self.client_certificate = client_certificate if client_certificate is not None else ''
5719        self.client_key = client_key if client_key is not None else ''
5720        self.egress_filter = egress_filter if egress_filter is not None else ''
5721        '''
5722         A filter applied to the routing logic to pin datasource to nodes.
5723        '''
5724        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5725        '''
5726         The path used to check the health of your connection.  Defaults to `default`.
5727        '''
5728        self.healthy = healthy if healthy is not None else False
5729        '''
5730         True if the datasource is reachable and the credentials are valid.
5731        '''
5732        self.hostname = hostname if hostname is not None else ''
5733        self.id = id if id is not None else ''
5734        '''
5735         Unique identifier of the Resource.
5736        '''
5737        self.name = name if name is not None else ''
5738        '''
5739         Unique human-readable name of the Resource.
5740        '''
5741        self.port = port if port is not None else 0
5742        self.port_override = port_override if port_override is not None else 0
5743        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5744        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5745        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5746        '''
5747         ID of the secret store containing credentials for this resource, if any.
5748        '''
5749        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5750        '''
5751         Tags is a map of key, value pairs.
5752        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5774    def to_dict(self):
5775        return {
5776            'bind_interface': self.bind_interface,
5777            'certificate_authority': self.certificate_authority,
5778            'client_certificate': self.client_certificate,
5779            'client_key': self.client_key,
5780            'egress_filter': self.egress_filter,
5781            'healthcheck_namespace': self.healthcheck_namespace,
5782            'healthy': self.healthy,
5783            'hostname': self.hostname,
5784            'id': self.id,
5785            'name': self.name,
5786            'port': self.port,
5787            'port_override': self.port_override,
5788            'remote_identity_group_id': self.remote_identity_group_id,
5789            'remote_identity_healthcheck_username':
5790            self.remote_identity_healthcheck_username,
5791            'secret_store_id': self.secret_store_id,
5792            'tags': self.tags,
5793        }
@classmethod
def from_dict(cls, d)
5795    @classmethod
5796    def from_dict(cls, d):
5797        return cls(
5798            bind_interface=d.get('bind_interface'),
5799            certificate_authority=d.get('certificate_authority'),
5800            client_certificate=d.get('client_certificate'),
5801            client_key=d.get('client_key'),
5802            egress_filter=d.get('egress_filter'),
5803            healthcheck_namespace=d.get('healthcheck_namespace'),
5804            healthy=d.get('healthy'),
5805            hostname=d.get('hostname'),
5806            id=d.get('id'),
5807            name=d.get('name'),
5808            port=d.get('port'),
5809            port_override=d.get('port_override'),
5810            remote_identity_group_id=d.get('remote_identity_group_id'),
5811            remote_identity_healthcheck_username=d.get(
5812                'remote_identity_healthcheck_username'),
5813            secret_store_id=d.get('secret_store_id'),
5814            tags=d.get('tags'),
5815        )
class KubernetesBasicAuth:
5818class KubernetesBasicAuth:
5819    __slots__ = [
5820        'bind_interface',
5821        'egress_filter',
5822        'healthcheck_namespace',
5823        'healthy',
5824        'hostname',
5825        'id',
5826        'name',
5827        'password',
5828        'port',
5829        'port_override',
5830        'secret_store_id',
5831        'tags',
5832        'username',
5833    ]
5834
5835    def __init__(
5836        self,
5837        bind_interface=None,
5838        egress_filter=None,
5839        healthcheck_namespace=None,
5840        healthy=None,
5841        hostname=None,
5842        id=None,
5843        name=None,
5844        password=None,
5845        port=None,
5846        port_override=None,
5847        secret_store_id=None,
5848        tags=None,
5849        username=None,
5850    ):
5851        self.bind_interface = bind_interface if bind_interface is not None else ''
5852        '''
5853         Bind interface
5854        '''
5855        self.egress_filter = egress_filter if egress_filter is not None else ''
5856        '''
5857         A filter applied to the routing logic to pin datasource to nodes.
5858        '''
5859        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5860        '''
5861         The path used to check the health of your connection.  Defaults to `default`.
5862        '''
5863        self.healthy = healthy if healthy is not None else False
5864        '''
5865         True if the datasource is reachable and the credentials are valid.
5866        '''
5867        self.hostname = hostname if hostname is not None else ''
5868        self.id = id if id is not None else ''
5869        '''
5870         Unique identifier of the Resource.
5871        '''
5872        self.name = name if name is not None else ''
5873        '''
5874         Unique human-readable name of the Resource.
5875        '''
5876        self.password = password if password is not None else ''
5877        self.port = port if port is not None else 0
5878        self.port_override = port_override if port_override is not None else 0
5879        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5880        '''
5881         ID of the secret store containing credentials for this resource, if any.
5882        '''
5883        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5884        '''
5885         Tags is a map of key, value pairs.
5886        '''
5887        self.username = username if username is not None else ''
5888
5889    def __repr__(self):
5890        return '<sdm.KubernetesBasicAuth ' + \
5891            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5892            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5893            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5894            'healthy: ' + repr(self.healthy) + ' ' +\
5895            'hostname: ' + repr(self.hostname) + ' ' +\
5896            'id: ' + repr(self.id) + ' ' +\
5897            'name: ' + repr(self.name) + ' ' +\
5898            'password: ' + repr(self.password) + ' ' +\
5899            'port: ' + repr(self.port) + ' ' +\
5900            'port_override: ' + repr(self.port_override) + ' ' +\
5901            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5902            'tags: ' + repr(self.tags) + ' ' +\
5903            'username: ' + repr(self.username) + ' ' +\
5904            '>'
5905
5906    def to_dict(self):
5907        return {
5908            'bind_interface': self.bind_interface,
5909            'egress_filter': self.egress_filter,
5910            'healthcheck_namespace': self.healthcheck_namespace,
5911            'healthy': self.healthy,
5912            'hostname': self.hostname,
5913            'id': self.id,
5914            'name': self.name,
5915            'password': self.password,
5916            'port': self.port,
5917            'port_override': self.port_override,
5918            'secret_store_id': self.secret_store_id,
5919            'tags': self.tags,
5920            'username': self.username,
5921        }
5922
5923    @classmethod
5924    def from_dict(cls, d):
5925        return cls(
5926            bind_interface=d.get('bind_interface'),
5927            egress_filter=d.get('egress_filter'),
5928            healthcheck_namespace=d.get('healthcheck_namespace'),
5929            healthy=d.get('healthy'),
5930            hostname=d.get('hostname'),
5931            id=d.get('id'),
5932            name=d.get('name'),
5933            password=d.get('password'),
5934            port=d.get('port'),
5935            port_override=d.get('port_override'),
5936            secret_store_id=d.get('secret_store_id'),
5937            tags=d.get('tags'),
5938            username=d.get('username'),
5939        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5835    def __init__(
5836        self,
5837        bind_interface=None,
5838        egress_filter=None,
5839        healthcheck_namespace=None,
5840        healthy=None,
5841        hostname=None,
5842        id=None,
5843        name=None,
5844        password=None,
5845        port=None,
5846        port_override=None,
5847        secret_store_id=None,
5848        tags=None,
5849        username=None,
5850    ):
5851        self.bind_interface = bind_interface if bind_interface is not None else ''
5852        '''
5853         Bind interface
5854        '''
5855        self.egress_filter = egress_filter if egress_filter is not None else ''
5856        '''
5857         A filter applied to the routing logic to pin datasource to nodes.
5858        '''
5859        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5860        '''
5861         The path used to check the health of your connection.  Defaults to `default`.
5862        '''
5863        self.healthy = healthy if healthy is not None else False
5864        '''
5865         True if the datasource is reachable and the credentials are valid.
5866        '''
5867        self.hostname = hostname if hostname is not None else ''
5868        self.id = id if id is not None else ''
5869        '''
5870         Unique identifier of the Resource.
5871        '''
5872        self.name = name if name is not None else ''
5873        '''
5874         Unique human-readable name of the Resource.
5875        '''
5876        self.password = password if password is not None else ''
5877        self.port = port if port is not None else 0
5878        self.port_override = port_override if port_override is not None else 0
5879        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5880        '''
5881         ID of the secret store containing credentials for this resource, if any.
5882        '''
5883        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5884        '''
5885         Tags is a map of key, value pairs.
5886        '''
5887        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5906    def to_dict(self):
5907        return {
5908            'bind_interface': self.bind_interface,
5909            'egress_filter': self.egress_filter,
5910            'healthcheck_namespace': self.healthcheck_namespace,
5911            'healthy': self.healthy,
5912            'hostname': self.hostname,
5913            'id': self.id,
5914            'name': self.name,
5915            'password': self.password,
5916            'port': self.port,
5917            'port_override': self.port_override,
5918            'secret_store_id': self.secret_store_id,
5919            'tags': self.tags,
5920            'username': self.username,
5921        }
@classmethod
def from_dict(cls, d)
5923    @classmethod
5924    def from_dict(cls, d):
5925        return cls(
5926            bind_interface=d.get('bind_interface'),
5927            egress_filter=d.get('egress_filter'),
5928            healthcheck_namespace=d.get('healthcheck_namespace'),
5929            healthy=d.get('healthy'),
5930            hostname=d.get('hostname'),
5931            id=d.get('id'),
5932            name=d.get('name'),
5933            password=d.get('password'),
5934            port=d.get('port'),
5935            port_override=d.get('port_override'),
5936            secret_store_id=d.get('secret_store_id'),
5937            tags=d.get('tags'),
5938            username=d.get('username'),
5939        )
class KubernetesServiceAccount:
5942class KubernetesServiceAccount:
5943    __slots__ = [
5944        'bind_interface',
5945        'egress_filter',
5946        'healthcheck_namespace',
5947        'healthy',
5948        'hostname',
5949        'id',
5950        'name',
5951        'port',
5952        'port_override',
5953        'remote_identity_group_id',
5954        'remote_identity_healthcheck_username',
5955        'secret_store_id',
5956        'tags',
5957        'token',
5958    ]
5959
5960    def __init__(
5961        self,
5962        bind_interface=None,
5963        egress_filter=None,
5964        healthcheck_namespace=None,
5965        healthy=None,
5966        hostname=None,
5967        id=None,
5968        name=None,
5969        port=None,
5970        port_override=None,
5971        remote_identity_group_id=None,
5972        remote_identity_healthcheck_username=None,
5973        secret_store_id=None,
5974        tags=None,
5975        token=None,
5976    ):
5977        self.bind_interface = bind_interface if bind_interface is not None else ''
5978        '''
5979         Bind interface
5980        '''
5981        self.egress_filter = egress_filter if egress_filter is not None else ''
5982        '''
5983         A filter applied to the routing logic to pin datasource to nodes.
5984        '''
5985        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5986        '''
5987         The path used to check the health of your connection.  Defaults to `default`.
5988        '''
5989        self.healthy = healthy if healthy is not None else False
5990        '''
5991         True if the datasource is reachable and the credentials are valid.
5992        '''
5993        self.hostname = hostname if hostname is not None else ''
5994        self.id = id if id is not None else ''
5995        '''
5996         Unique identifier of the Resource.
5997        '''
5998        self.name = name if name is not None else ''
5999        '''
6000         Unique human-readable name of the Resource.
6001        '''
6002        self.port = port if port is not None else 0
6003        self.port_override = port_override if port_override is not None else 0
6004        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6005        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6007        '''
6008         ID of the secret store containing credentials for this resource, if any.
6009        '''
6010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6011        '''
6012         Tags is a map of key, value pairs.
6013        '''
6014        self.token = token if token is not None else ''
6015
6016    def __repr__(self):
6017        return '<sdm.KubernetesServiceAccount ' + \
6018            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6019            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6020            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6021            'healthy: ' + repr(self.healthy) + ' ' +\
6022            'hostname: ' + repr(self.hostname) + ' ' +\
6023            'id: ' + repr(self.id) + ' ' +\
6024            'name: ' + repr(self.name) + ' ' +\
6025            'port: ' + repr(self.port) + ' ' +\
6026            'port_override: ' + repr(self.port_override) + ' ' +\
6027            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6028            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6030            'tags: ' + repr(self.tags) + ' ' +\
6031            'token: ' + repr(self.token) + ' ' +\
6032            '>'
6033
6034    def to_dict(self):
6035        return {
6036            'bind_interface': self.bind_interface,
6037            'egress_filter': self.egress_filter,
6038            'healthcheck_namespace': self.healthcheck_namespace,
6039            'healthy': self.healthy,
6040            'hostname': self.hostname,
6041            'id': self.id,
6042            'name': self.name,
6043            'port': self.port,
6044            'port_override': self.port_override,
6045            'remote_identity_group_id': self.remote_identity_group_id,
6046            'remote_identity_healthcheck_username':
6047            self.remote_identity_healthcheck_username,
6048            'secret_store_id': self.secret_store_id,
6049            'tags': self.tags,
6050            'token': self.token,
6051        }
6052
6053    @classmethod
6054    def from_dict(cls, d):
6055        return cls(
6056            bind_interface=d.get('bind_interface'),
6057            egress_filter=d.get('egress_filter'),
6058            healthcheck_namespace=d.get('healthcheck_namespace'),
6059            healthy=d.get('healthy'),
6060            hostname=d.get('hostname'),
6061            id=d.get('id'),
6062            name=d.get('name'),
6063            port=d.get('port'),
6064            port_override=d.get('port_override'),
6065            remote_identity_group_id=d.get('remote_identity_group_id'),
6066            remote_identity_healthcheck_username=d.get(
6067                'remote_identity_healthcheck_username'),
6068            secret_store_id=d.get('secret_store_id'),
6069            tags=d.get('tags'),
6070            token=d.get('token'),
6071        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
5960    def __init__(
5961        self,
5962        bind_interface=None,
5963        egress_filter=None,
5964        healthcheck_namespace=None,
5965        healthy=None,
5966        hostname=None,
5967        id=None,
5968        name=None,
5969        port=None,
5970        port_override=None,
5971        remote_identity_group_id=None,
5972        remote_identity_healthcheck_username=None,
5973        secret_store_id=None,
5974        tags=None,
5975        token=None,
5976    ):
5977        self.bind_interface = bind_interface if bind_interface is not None else ''
5978        '''
5979         Bind interface
5980        '''
5981        self.egress_filter = egress_filter if egress_filter is not None else ''
5982        '''
5983         A filter applied to the routing logic to pin datasource to nodes.
5984        '''
5985        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5986        '''
5987         The path used to check the health of your connection.  Defaults to `default`.
5988        '''
5989        self.healthy = healthy if healthy is not None else False
5990        '''
5991         True if the datasource is reachable and the credentials are valid.
5992        '''
5993        self.hostname = hostname if hostname is not None else ''
5994        self.id = id if id is not None else ''
5995        '''
5996         Unique identifier of the Resource.
5997        '''
5998        self.name = name if name is not None else ''
5999        '''
6000         Unique human-readable name of the Resource.
6001        '''
6002        self.port = port if port is not None else 0
6003        self.port_override = port_override if port_override is not None else 0
6004        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6005        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6007        '''
6008         ID of the secret store containing credentials for this resource, if any.
6009        '''
6010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6011        '''
6012         Tags is a map of key, value pairs.
6013        '''
6014        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6034    def to_dict(self):
6035        return {
6036            'bind_interface': self.bind_interface,
6037            'egress_filter': self.egress_filter,
6038            'healthcheck_namespace': self.healthcheck_namespace,
6039            'healthy': self.healthy,
6040            'hostname': self.hostname,
6041            'id': self.id,
6042            'name': self.name,
6043            'port': self.port,
6044            'port_override': self.port_override,
6045            'remote_identity_group_id': self.remote_identity_group_id,
6046            'remote_identity_healthcheck_username':
6047            self.remote_identity_healthcheck_username,
6048            'secret_store_id': self.secret_store_id,
6049            'tags': self.tags,
6050            'token': self.token,
6051        }
@classmethod
def from_dict(cls, d)
6053    @classmethod
6054    def from_dict(cls, d):
6055        return cls(
6056            bind_interface=d.get('bind_interface'),
6057            egress_filter=d.get('egress_filter'),
6058            healthcheck_namespace=d.get('healthcheck_namespace'),
6059            healthy=d.get('healthy'),
6060            hostname=d.get('hostname'),
6061            id=d.get('id'),
6062            name=d.get('name'),
6063            port=d.get('port'),
6064            port_override=d.get('port_override'),
6065            remote_identity_group_id=d.get('remote_identity_group_id'),
6066            remote_identity_healthcheck_username=d.get(
6067                'remote_identity_healthcheck_username'),
6068            secret_store_id=d.get('secret_store_id'),
6069            tags=d.get('tags'),
6070            token=d.get('token'),
6071        )
class KubernetesServiceAccountUserImpersonation:
6074class KubernetesServiceAccountUserImpersonation:
6075    __slots__ = [
6076        'bind_interface',
6077        'egress_filter',
6078        'healthcheck_namespace',
6079        'healthy',
6080        'hostname',
6081        'id',
6082        'name',
6083        'port',
6084        'port_override',
6085        'secret_store_id',
6086        'tags',
6087        'token',
6088    ]
6089
6090    def __init__(
6091        self,
6092        bind_interface=None,
6093        egress_filter=None,
6094        healthcheck_namespace=None,
6095        healthy=None,
6096        hostname=None,
6097        id=None,
6098        name=None,
6099        port=None,
6100        port_override=None,
6101        secret_store_id=None,
6102        tags=None,
6103        token=None,
6104    ):
6105        self.bind_interface = bind_interface if bind_interface is not None else ''
6106        '''
6107         Bind interface
6108        '''
6109        self.egress_filter = egress_filter if egress_filter is not None else ''
6110        '''
6111         A filter applied to the routing logic to pin datasource to nodes.
6112        '''
6113        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6114        '''
6115         The path used to check the health of your connection.  Defaults to `default`.
6116        '''
6117        self.healthy = healthy if healthy is not None else False
6118        '''
6119         True if the datasource is reachable and the credentials are valid.
6120        '''
6121        self.hostname = hostname if hostname is not None else ''
6122        self.id = id if id is not None else ''
6123        '''
6124         Unique identifier of the Resource.
6125        '''
6126        self.name = name if name is not None else ''
6127        '''
6128         Unique human-readable name of the Resource.
6129        '''
6130        self.port = port if port is not None else 0
6131        self.port_override = port_override if port_override is not None else 0
6132        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6133        '''
6134         ID of the secret store containing credentials for this resource, if any.
6135        '''
6136        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6137        '''
6138         Tags is a map of key, value pairs.
6139        '''
6140        self.token = token if token is not None else ''
6141
6142    def __repr__(self):
6143        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6144            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6145            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6146            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6147            'healthy: ' + repr(self.healthy) + ' ' +\
6148            'hostname: ' + repr(self.hostname) + ' ' +\
6149            'id: ' + repr(self.id) + ' ' +\
6150            'name: ' + repr(self.name) + ' ' +\
6151            'port: ' + repr(self.port) + ' ' +\
6152            'port_override: ' + repr(self.port_override) + ' ' +\
6153            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6154            'tags: ' + repr(self.tags) + ' ' +\
6155            'token: ' + repr(self.token) + ' ' +\
6156            '>'
6157
6158    def to_dict(self):
6159        return {
6160            'bind_interface': self.bind_interface,
6161            'egress_filter': self.egress_filter,
6162            'healthcheck_namespace': self.healthcheck_namespace,
6163            'healthy': self.healthy,
6164            'hostname': self.hostname,
6165            'id': self.id,
6166            'name': self.name,
6167            'port': self.port,
6168            'port_override': self.port_override,
6169            'secret_store_id': self.secret_store_id,
6170            'tags': self.tags,
6171            'token': self.token,
6172        }
6173
6174    @classmethod
6175    def from_dict(cls, d):
6176        return cls(
6177            bind_interface=d.get('bind_interface'),
6178            egress_filter=d.get('egress_filter'),
6179            healthcheck_namespace=d.get('healthcheck_namespace'),
6180            healthy=d.get('healthy'),
6181            hostname=d.get('hostname'),
6182            id=d.get('id'),
6183            name=d.get('name'),
6184            port=d.get('port'),
6185            port_override=d.get('port_override'),
6186            secret_store_id=d.get('secret_store_id'),
6187            tags=d.get('tags'),
6188            token=d.get('token'),
6189        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6090    def __init__(
6091        self,
6092        bind_interface=None,
6093        egress_filter=None,
6094        healthcheck_namespace=None,
6095        healthy=None,
6096        hostname=None,
6097        id=None,
6098        name=None,
6099        port=None,
6100        port_override=None,
6101        secret_store_id=None,
6102        tags=None,
6103        token=None,
6104    ):
6105        self.bind_interface = bind_interface if bind_interface is not None else ''
6106        '''
6107         Bind interface
6108        '''
6109        self.egress_filter = egress_filter if egress_filter is not None else ''
6110        '''
6111         A filter applied to the routing logic to pin datasource to nodes.
6112        '''
6113        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6114        '''
6115         The path used to check the health of your connection.  Defaults to `default`.
6116        '''
6117        self.healthy = healthy if healthy is not None else False
6118        '''
6119         True if the datasource is reachable and the credentials are valid.
6120        '''
6121        self.hostname = hostname if hostname is not None else ''
6122        self.id = id if id is not None else ''
6123        '''
6124         Unique identifier of the Resource.
6125        '''
6126        self.name = name if name is not None else ''
6127        '''
6128         Unique human-readable name of the Resource.
6129        '''
6130        self.port = port if port is not None else 0
6131        self.port_override = port_override if port_override is not None else 0
6132        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6133        '''
6134         ID of the secret store containing credentials for this resource, if any.
6135        '''
6136        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6137        '''
6138         Tags is a map of key, value pairs.
6139        '''
6140        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6158    def to_dict(self):
6159        return {
6160            'bind_interface': self.bind_interface,
6161            'egress_filter': self.egress_filter,
6162            'healthcheck_namespace': self.healthcheck_namespace,
6163            'healthy': self.healthy,
6164            'hostname': self.hostname,
6165            'id': self.id,
6166            'name': self.name,
6167            'port': self.port,
6168            'port_override': self.port_override,
6169            'secret_store_id': self.secret_store_id,
6170            'tags': self.tags,
6171            'token': self.token,
6172        }
@classmethod
def from_dict(cls, d)
6174    @classmethod
6175    def from_dict(cls, d):
6176        return cls(
6177            bind_interface=d.get('bind_interface'),
6178            egress_filter=d.get('egress_filter'),
6179            healthcheck_namespace=d.get('healthcheck_namespace'),
6180            healthy=d.get('healthy'),
6181            hostname=d.get('hostname'),
6182            id=d.get('id'),
6183            name=d.get('name'),
6184            port=d.get('port'),
6185            port_override=d.get('port_override'),
6186            secret_store_id=d.get('secret_store_id'),
6187            tags=d.get('tags'),
6188            token=d.get('token'),
6189        )
class KubernetesUserImpersonation:
6192class KubernetesUserImpersonation:
6193    __slots__ = [
6194        'bind_interface',
6195        'certificate_authority',
6196        'client_certificate',
6197        'client_key',
6198        'egress_filter',
6199        'healthcheck_namespace',
6200        'healthy',
6201        'hostname',
6202        'id',
6203        'name',
6204        'port',
6205        'port_override',
6206        'secret_store_id',
6207        'tags',
6208    ]
6209
6210    def __init__(
6211        self,
6212        bind_interface=None,
6213        certificate_authority=None,
6214        client_certificate=None,
6215        client_key=None,
6216        egress_filter=None,
6217        healthcheck_namespace=None,
6218        healthy=None,
6219        hostname=None,
6220        id=None,
6221        name=None,
6222        port=None,
6223        port_override=None,
6224        secret_store_id=None,
6225        tags=None,
6226    ):
6227        self.bind_interface = bind_interface if bind_interface is not None else ''
6228        '''
6229         Bind interface
6230        '''
6231        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6232        self.client_certificate = client_certificate if client_certificate is not None else ''
6233        self.client_key = client_key if client_key is not None else ''
6234        self.egress_filter = egress_filter if egress_filter is not None else ''
6235        '''
6236         A filter applied to the routing logic to pin datasource to nodes.
6237        '''
6238        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6239        '''
6240         The path used to check the health of your connection.  Defaults to `default`.
6241        '''
6242        self.healthy = healthy if healthy is not None else False
6243        '''
6244         True if the datasource is reachable and the credentials are valid.
6245        '''
6246        self.hostname = hostname if hostname is not None else ''
6247        self.id = id if id is not None else ''
6248        '''
6249         Unique identifier of the Resource.
6250        '''
6251        self.name = name if name is not None else ''
6252        '''
6253         Unique human-readable name of the Resource.
6254        '''
6255        self.port = port if port is not None else 0
6256        self.port_override = port_override if port_override is not None else 0
6257        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6258        '''
6259         ID of the secret store containing credentials for this resource, if any.
6260        '''
6261        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6262        '''
6263         Tags is a map of key, value pairs.
6264        '''
6265
6266    def __repr__(self):
6267        return '<sdm.KubernetesUserImpersonation ' + \
6268            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6269            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6270            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6271            'client_key: ' + repr(self.client_key) + ' ' +\
6272            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6273            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6274            'healthy: ' + repr(self.healthy) + ' ' +\
6275            'hostname: ' + repr(self.hostname) + ' ' +\
6276            'id: ' + repr(self.id) + ' ' +\
6277            'name: ' + repr(self.name) + ' ' +\
6278            'port: ' + repr(self.port) + ' ' +\
6279            'port_override: ' + repr(self.port_override) + ' ' +\
6280            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6281            'tags: ' + repr(self.tags) + ' ' +\
6282            '>'
6283
6284    def to_dict(self):
6285        return {
6286            'bind_interface': self.bind_interface,
6287            'certificate_authority': self.certificate_authority,
6288            'client_certificate': self.client_certificate,
6289            'client_key': self.client_key,
6290            'egress_filter': self.egress_filter,
6291            'healthcheck_namespace': self.healthcheck_namespace,
6292            'healthy': self.healthy,
6293            'hostname': self.hostname,
6294            'id': self.id,
6295            'name': self.name,
6296            'port': self.port,
6297            'port_override': self.port_override,
6298            'secret_store_id': self.secret_store_id,
6299            'tags': self.tags,
6300        }
6301
6302    @classmethod
6303    def from_dict(cls, d):
6304        return cls(
6305            bind_interface=d.get('bind_interface'),
6306            certificate_authority=d.get('certificate_authority'),
6307            client_certificate=d.get('client_certificate'),
6308            client_key=d.get('client_key'),
6309            egress_filter=d.get('egress_filter'),
6310            healthcheck_namespace=d.get('healthcheck_namespace'),
6311            healthy=d.get('healthy'),
6312            hostname=d.get('hostname'),
6313            id=d.get('id'),
6314            name=d.get('name'),
6315            port=d.get('port'),
6316            port_override=d.get('port_override'),
6317            secret_store_id=d.get('secret_store_id'),
6318            tags=d.get('tags'),
6319        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6210    def __init__(
6211        self,
6212        bind_interface=None,
6213        certificate_authority=None,
6214        client_certificate=None,
6215        client_key=None,
6216        egress_filter=None,
6217        healthcheck_namespace=None,
6218        healthy=None,
6219        hostname=None,
6220        id=None,
6221        name=None,
6222        port=None,
6223        port_override=None,
6224        secret_store_id=None,
6225        tags=None,
6226    ):
6227        self.bind_interface = bind_interface if bind_interface is not None else ''
6228        '''
6229         Bind interface
6230        '''
6231        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6232        self.client_certificate = client_certificate if client_certificate is not None else ''
6233        self.client_key = client_key if client_key is not None else ''
6234        self.egress_filter = egress_filter if egress_filter is not None else ''
6235        '''
6236         A filter applied to the routing logic to pin datasource to nodes.
6237        '''
6238        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6239        '''
6240         The path used to check the health of your connection.  Defaults to `default`.
6241        '''
6242        self.healthy = healthy if healthy is not None else False
6243        '''
6244         True if the datasource is reachable and the credentials are valid.
6245        '''
6246        self.hostname = hostname if hostname is not None else ''
6247        self.id = id if id is not None else ''
6248        '''
6249         Unique identifier of the Resource.
6250        '''
6251        self.name = name if name is not None else ''
6252        '''
6253         Unique human-readable name of the Resource.
6254        '''
6255        self.port = port if port is not None else 0
6256        self.port_override = port_override if port_override is not None else 0
6257        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6258        '''
6259         ID of the secret store containing credentials for this resource, if any.
6260        '''
6261        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6262        '''
6263         Tags is a map of key, value pairs.
6264        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6284    def to_dict(self):
6285        return {
6286            'bind_interface': self.bind_interface,
6287            'certificate_authority': self.certificate_authority,
6288            'client_certificate': self.client_certificate,
6289            'client_key': self.client_key,
6290            'egress_filter': self.egress_filter,
6291            'healthcheck_namespace': self.healthcheck_namespace,
6292            'healthy': self.healthy,
6293            'hostname': self.hostname,
6294            'id': self.id,
6295            'name': self.name,
6296            'port': self.port,
6297            'port_override': self.port_override,
6298            'secret_store_id': self.secret_store_id,
6299            'tags': self.tags,
6300        }
@classmethod
def from_dict(cls, d)
6302    @classmethod
6303    def from_dict(cls, d):
6304        return cls(
6305            bind_interface=d.get('bind_interface'),
6306            certificate_authority=d.get('certificate_authority'),
6307            client_certificate=d.get('client_certificate'),
6308            client_key=d.get('client_key'),
6309            egress_filter=d.get('egress_filter'),
6310            healthcheck_namespace=d.get('healthcheck_namespace'),
6311            healthy=d.get('healthy'),
6312            hostname=d.get('hostname'),
6313            id=d.get('id'),
6314            name=d.get('name'),
6315            port=d.get('port'),
6316            port_override=d.get('port_override'),
6317            secret_store_id=d.get('secret_store_id'),
6318            tags=d.get('tags'),
6319        )
class MTLSMysql:
6322class MTLSMysql:
6323    '''
6324    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6325    without a major version bump.
6326    '''
6327    __slots__ = [
6328        'bind_interface',
6329        'certificate_authority',
6330        'client_certificate',
6331        'client_key',
6332        'database',
6333        'egress_filter',
6334        'healthy',
6335        'hostname',
6336        'id',
6337        'name',
6338        'password',
6339        'port',
6340        'port_override',
6341        'secret_store_id',
6342        'server_name',
6343        'tags',
6344        'username',
6345    ]
6346
6347    def __init__(
6348        self,
6349        bind_interface=None,
6350        certificate_authority=None,
6351        client_certificate=None,
6352        client_key=None,
6353        database=None,
6354        egress_filter=None,
6355        healthy=None,
6356        hostname=None,
6357        id=None,
6358        name=None,
6359        password=None,
6360        port=None,
6361        port_override=None,
6362        secret_store_id=None,
6363        server_name=None,
6364        tags=None,
6365        username=None,
6366    ):
6367        self.bind_interface = bind_interface if bind_interface is not None else ''
6368        '''
6369         Bind interface
6370        '''
6371        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6372        self.client_certificate = client_certificate if client_certificate is not None else ''
6373        self.client_key = client_key if client_key is not None else ''
6374        self.database = database if database is not None else ''
6375        self.egress_filter = egress_filter if egress_filter is not None else ''
6376        '''
6377         A filter applied to the routing logic to pin datasource to nodes.
6378        '''
6379        self.healthy = healthy if healthy is not None else False
6380        '''
6381         True if the datasource is reachable and the credentials are valid.
6382        '''
6383        self.hostname = hostname if hostname is not None else ''
6384        self.id = id if id is not None else ''
6385        '''
6386         Unique identifier of the Resource.
6387        '''
6388        self.name = name if name is not None else ''
6389        '''
6390         Unique human-readable name of the Resource.
6391        '''
6392        self.password = password if password is not None else ''
6393        self.port = port if port is not None else 0
6394        self.port_override = port_override if port_override is not None else 0
6395        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6396        '''
6397         ID of the secret store containing credentials for this resource, if any.
6398        '''
6399        self.server_name = server_name if server_name is not None else ''
6400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6401        '''
6402         Tags is a map of key, value pairs.
6403        '''
6404        self.username = username if username is not None else ''
6405
6406    def __repr__(self):
6407        return '<sdm.MTLSMysql ' + \
6408            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6409            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6410            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6411            'client_key: ' + repr(self.client_key) + ' ' +\
6412            'database: ' + repr(self.database) + ' ' +\
6413            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6414            'healthy: ' + repr(self.healthy) + ' ' +\
6415            'hostname: ' + repr(self.hostname) + ' ' +\
6416            'id: ' + repr(self.id) + ' ' +\
6417            'name: ' + repr(self.name) + ' ' +\
6418            'password: ' + repr(self.password) + ' ' +\
6419            'port: ' + repr(self.port) + ' ' +\
6420            'port_override: ' + repr(self.port_override) + ' ' +\
6421            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6422            'server_name: ' + repr(self.server_name) + ' ' +\
6423            'tags: ' + repr(self.tags) + ' ' +\
6424            'username: ' + repr(self.username) + ' ' +\
6425            '>'
6426
6427    def to_dict(self):
6428        return {
6429            'bind_interface': self.bind_interface,
6430            'certificate_authority': self.certificate_authority,
6431            'client_certificate': self.client_certificate,
6432            'client_key': self.client_key,
6433            'database': self.database,
6434            'egress_filter': self.egress_filter,
6435            'healthy': self.healthy,
6436            'hostname': self.hostname,
6437            'id': self.id,
6438            'name': self.name,
6439            'password': self.password,
6440            'port': self.port,
6441            'port_override': self.port_override,
6442            'secret_store_id': self.secret_store_id,
6443            'server_name': self.server_name,
6444            'tags': self.tags,
6445            'username': self.username,
6446        }
6447
6448    @classmethod
6449    def from_dict(cls, d):
6450        return cls(
6451            bind_interface=d.get('bind_interface'),
6452            certificate_authority=d.get('certificate_authority'),
6453            client_certificate=d.get('client_certificate'),
6454            client_key=d.get('client_key'),
6455            database=d.get('database'),
6456            egress_filter=d.get('egress_filter'),
6457            healthy=d.get('healthy'),
6458            hostname=d.get('hostname'),
6459            id=d.get('id'),
6460            name=d.get('name'),
6461            password=d.get('password'),
6462            port=d.get('port'),
6463            port_override=d.get('port_override'),
6464            secret_store_id=d.get('secret_store_id'),
6465            server_name=d.get('server_name'),
6466            tags=d.get('tags'),
6467            username=d.get('username'),
6468        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6347    def __init__(
6348        self,
6349        bind_interface=None,
6350        certificate_authority=None,
6351        client_certificate=None,
6352        client_key=None,
6353        database=None,
6354        egress_filter=None,
6355        healthy=None,
6356        hostname=None,
6357        id=None,
6358        name=None,
6359        password=None,
6360        port=None,
6361        port_override=None,
6362        secret_store_id=None,
6363        server_name=None,
6364        tags=None,
6365        username=None,
6366    ):
6367        self.bind_interface = bind_interface if bind_interface is not None else ''
6368        '''
6369         Bind interface
6370        '''
6371        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6372        self.client_certificate = client_certificate if client_certificate is not None else ''
6373        self.client_key = client_key if client_key is not None else ''
6374        self.database = database if database is not None else ''
6375        self.egress_filter = egress_filter if egress_filter is not None else ''
6376        '''
6377         A filter applied to the routing logic to pin datasource to nodes.
6378        '''
6379        self.healthy = healthy if healthy is not None else False
6380        '''
6381         True if the datasource is reachable and the credentials are valid.
6382        '''
6383        self.hostname = hostname if hostname is not None else ''
6384        self.id = id if id is not None else ''
6385        '''
6386         Unique identifier of the Resource.
6387        '''
6388        self.name = name if name is not None else ''
6389        '''
6390         Unique human-readable name of the Resource.
6391        '''
6392        self.password = password if password is not None else ''
6393        self.port = port if port is not None else 0
6394        self.port_override = port_override if port_override is not None else 0
6395        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6396        '''
6397         ID of the secret store containing credentials for this resource, if any.
6398        '''
6399        self.server_name = server_name if server_name is not None else ''
6400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6401        '''
6402         Tags is a map of key, value pairs.
6403        '''
6404        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6427    def to_dict(self):
6428        return {
6429            'bind_interface': self.bind_interface,
6430            'certificate_authority': self.certificate_authority,
6431            'client_certificate': self.client_certificate,
6432            'client_key': self.client_key,
6433            'database': self.database,
6434            'egress_filter': self.egress_filter,
6435            'healthy': self.healthy,
6436            'hostname': self.hostname,
6437            'id': self.id,
6438            'name': self.name,
6439            'password': self.password,
6440            'port': self.port,
6441            'port_override': self.port_override,
6442            'secret_store_id': self.secret_store_id,
6443            'server_name': self.server_name,
6444            'tags': self.tags,
6445            'username': self.username,
6446        }
@classmethod
def from_dict(cls, d)
6448    @classmethod
6449    def from_dict(cls, d):
6450        return cls(
6451            bind_interface=d.get('bind_interface'),
6452            certificate_authority=d.get('certificate_authority'),
6453            client_certificate=d.get('client_certificate'),
6454            client_key=d.get('client_key'),
6455            database=d.get('database'),
6456            egress_filter=d.get('egress_filter'),
6457            healthy=d.get('healthy'),
6458            hostname=d.get('hostname'),
6459            id=d.get('id'),
6460            name=d.get('name'),
6461            password=d.get('password'),
6462            port=d.get('port'),
6463            port_override=d.get('port_override'),
6464            secret_store_id=d.get('secret_store_id'),
6465            server_name=d.get('server_name'),
6466            tags=d.get('tags'),
6467            username=d.get('username'),
6468        )
class MTLSPostgres:
6471class MTLSPostgres:
6472    __slots__ = [
6473        'bind_interface',
6474        'certificate_authority',
6475        'client_certificate',
6476        'client_key',
6477        'database',
6478        'egress_filter',
6479        'healthy',
6480        'hostname',
6481        'id',
6482        'name',
6483        'override_database',
6484        'password',
6485        'port',
6486        'port_override',
6487        'secret_store_id',
6488        'server_name',
6489        'tags',
6490        'username',
6491    ]
6492
6493    def __init__(
6494        self,
6495        bind_interface=None,
6496        certificate_authority=None,
6497        client_certificate=None,
6498        client_key=None,
6499        database=None,
6500        egress_filter=None,
6501        healthy=None,
6502        hostname=None,
6503        id=None,
6504        name=None,
6505        override_database=None,
6506        password=None,
6507        port=None,
6508        port_override=None,
6509        secret_store_id=None,
6510        server_name=None,
6511        tags=None,
6512        username=None,
6513    ):
6514        self.bind_interface = bind_interface if bind_interface is not None else ''
6515        '''
6516         Bind interface
6517        '''
6518        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6519        self.client_certificate = client_certificate if client_certificate is not None else ''
6520        self.client_key = client_key if client_key is not None else ''
6521        self.database = database if database is not None else ''
6522        self.egress_filter = egress_filter if egress_filter is not None else ''
6523        '''
6524         A filter applied to the routing logic to pin datasource to nodes.
6525        '''
6526        self.healthy = healthy if healthy is not None else False
6527        '''
6528         True if the datasource is reachable and the credentials are valid.
6529        '''
6530        self.hostname = hostname if hostname is not None else ''
6531        self.id = id if id is not None else ''
6532        '''
6533         Unique identifier of the Resource.
6534        '''
6535        self.name = name if name is not None else ''
6536        '''
6537         Unique human-readable name of the Resource.
6538        '''
6539        self.override_database = override_database if override_database is not None else False
6540        self.password = password if password is not None else ''
6541        self.port = port if port is not None else 0
6542        self.port_override = port_override if port_override is not None else 0
6543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6544        '''
6545         ID of the secret store containing credentials for this resource, if any.
6546        '''
6547        self.server_name = server_name if server_name is not None else ''
6548        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6549        '''
6550         Tags is a map of key, value pairs.
6551        '''
6552        self.username = username if username is not None else ''
6553
6554    def __repr__(self):
6555        return '<sdm.MTLSPostgres ' + \
6556            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6557            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6558            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6559            'client_key: ' + repr(self.client_key) + ' ' +\
6560            'database: ' + repr(self.database) + ' ' +\
6561            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6562            'healthy: ' + repr(self.healthy) + ' ' +\
6563            'hostname: ' + repr(self.hostname) + ' ' +\
6564            'id: ' + repr(self.id) + ' ' +\
6565            'name: ' + repr(self.name) + ' ' +\
6566            'override_database: ' + repr(self.override_database) + ' ' +\
6567            'password: ' + repr(self.password) + ' ' +\
6568            'port: ' + repr(self.port) + ' ' +\
6569            'port_override: ' + repr(self.port_override) + ' ' +\
6570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6571            'server_name: ' + repr(self.server_name) + ' ' +\
6572            'tags: ' + repr(self.tags) + ' ' +\
6573            'username: ' + repr(self.username) + ' ' +\
6574            '>'
6575
6576    def to_dict(self):
6577        return {
6578            'bind_interface': self.bind_interface,
6579            'certificate_authority': self.certificate_authority,
6580            'client_certificate': self.client_certificate,
6581            'client_key': self.client_key,
6582            'database': self.database,
6583            'egress_filter': self.egress_filter,
6584            'healthy': self.healthy,
6585            'hostname': self.hostname,
6586            'id': self.id,
6587            'name': self.name,
6588            'override_database': self.override_database,
6589            'password': self.password,
6590            'port': self.port,
6591            'port_override': self.port_override,
6592            'secret_store_id': self.secret_store_id,
6593            'server_name': self.server_name,
6594            'tags': self.tags,
6595            'username': self.username,
6596        }
6597
6598    @classmethod
6599    def from_dict(cls, d):
6600        return cls(
6601            bind_interface=d.get('bind_interface'),
6602            certificate_authority=d.get('certificate_authority'),
6603            client_certificate=d.get('client_certificate'),
6604            client_key=d.get('client_key'),
6605            database=d.get('database'),
6606            egress_filter=d.get('egress_filter'),
6607            healthy=d.get('healthy'),
6608            hostname=d.get('hostname'),
6609            id=d.get('id'),
6610            name=d.get('name'),
6611            override_database=d.get('override_database'),
6612            password=d.get('password'),
6613            port=d.get('port'),
6614            port_override=d.get('port_override'),
6615            secret_store_id=d.get('secret_store_id'),
6616            server_name=d.get('server_name'),
6617            tags=d.get('tags'),
6618            username=d.get('username'),
6619        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6493    def __init__(
6494        self,
6495        bind_interface=None,
6496        certificate_authority=None,
6497        client_certificate=None,
6498        client_key=None,
6499        database=None,
6500        egress_filter=None,
6501        healthy=None,
6502        hostname=None,
6503        id=None,
6504        name=None,
6505        override_database=None,
6506        password=None,
6507        port=None,
6508        port_override=None,
6509        secret_store_id=None,
6510        server_name=None,
6511        tags=None,
6512        username=None,
6513    ):
6514        self.bind_interface = bind_interface if bind_interface is not None else ''
6515        '''
6516         Bind interface
6517        '''
6518        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6519        self.client_certificate = client_certificate if client_certificate is not None else ''
6520        self.client_key = client_key if client_key is not None else ''
6521        self.database = database if database is not None else ''
6522        self.egress_filter = egress_filter if egress_filter is not None else ''
6523        '''
6524         A filter applied to the routing logic to pin datasource to nodes.
6525        '''
6526        self.healthy = healthy if healthy is not None else False
6527        '''
6528         True if the datasource is reachable and the credentials are valid.
6529        '''
6530        self.hostname = hostname if hostname is not None else ''
6531        self.id = id if id is not None else ''
6532        '''
6533         Unique identifier of the Resource.
6534        '''
6535        self.name = name if name is not None else ''
6536        '''
6537         Unique human-readable name of the Resource.
6538        '''
6539        self.override_database = override_database if override_database is not None else False
6540        self.password = password if password is not None else ''
6541        self.port = port if port is not None else 0
6542        self.port_override = port_override if port_override is not None else 0
6543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6544        '''
6545         ID of the secret store containing credentials for this resource, if any.
6546        '''
6547        self.server_name = server_name if server_name is not None else ''
6548        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6549        '''
6550         Tags is a map of key, value pairs.
6551        '''
6552        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6576    def to_dict(self):
6577        return {
6578            'bind_interface': self.bind_interface,
6579            'certificate_authority': self.certificate_authority,
6580            'client_certificate': self.client_certificate,
6581            'client_key': self.client_key,
6582            'database': self.database,
6583            'egress_filter': self.egress_filter,
6584            'healthy': self.healthy,
6585            'hostname': self.hostname,
6586            'id': self.id,
6587            'name': self.name,
6588            'override_database': self.override_database,
6589            'password': self.password,
6590            'port': self.port,
6591            'port_override': self.port_override,
6592            'secret_store_id': self.secret_store_id,
6593            'server_name': self.server_name,
6594            'tags': self.tags,
6595            'username': self.username,
6596        }
@classmethod
def from_dict(cls, d)
6598    @classmethod
6599    def from_dict(cls, d):
6600        return cls(
6601            bind_interface=d.get('bind_interface'),
6602            certificate_authority=d.get('certificate_authority'),
6603            client_certificate=d.get('client_certificate'),
6604            client_key=d.get('client_key'),
6605            database=d.get('database'),
6606            egress_filter=d.get('egress_filter'),
6607            healthy=d.get('healthy'),
6608            hostname=d.get('hostname'),
6609            id=d.get('id'),
6610            name=d.get('name'),
6611            override_database=d.get('override_database'),
6612            password=d.get('password'),
6613            port=d.get('port'),
6614            port_override=d.get('port_override'),
6615            secret_store_id=d.get('secret_store_id'),
6616            server_name=d.get('server_name'),
6617            tags=d.get('tags'),
6618            username=d.get('username'),
6619        )
class Maria:
6622class Maria:
6623    __slots__ = [
6624        'bind_interface',
6625        'database',
6626        'egress_filter',
6627        'healthy',
6628        'hostname',
6629        'id',
6630        'name',
6631        'password',
6632        'port',
6633        'port_override',
6634        'secret_store_id',
6635        'tags',
6636        'username',
6637    ]
6638
6639    def __init__(
6640        self,
6641        bind_interface=None,
6642        database=None,
6643        egress_filter=None,
6644        healthy=None,
6645        hostname=None,
6646        id=None,
6647        name=None,
6648        password=None,
6649        port=None,
6650        port_override=None,
6651        secret_store_id=None,
6652        tags=None,
6653        username=None,
6654    ):
6655        self.bind_interface = bind_interface if bind_interface is not None else ''
6656        '''
6657         Bind interface
6658        '''
6659        self.database = database if database is not None else ''
6660        self.egress_filter = egress_filter if egress_filter is not None else ''
6661        '''
6662         A filter applied to the routing logic to pin datasource to nodes.
6663        '''
6664        self.healthy = healthy if healthy is not None else False
6665        '''
6666         True if the datasource is reachable and the credentials are valid.
6667        '''
6668        self.hostname = hostname if hostname is not None else ''
6669        self.id = id if id is not None else ''
6670        '''
6671         Unique identifier of the Resource.
6672        '''
6673        self.name = name if name is not None else ''
6674        '''
6675         Unique human-readable name of the Resource.
6676        '''
6677        self.password = password if password is not None else ''
6678        self.port = port if port is not None else 0
6679        self.port_override = port_override if port_override is not None else 0
6680        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6681        '''
6682         ID of the secret store containing credentials for this resource, if any.
6683        '''
6684        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6685        '''
6686         Tags is a map of key, value pairs.
6687        '''
6688        self.username = username if username is not None else ''
6689
6690    def __repr__(self):
6691        return '<sdm.Maria ' + \
6692            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6693            'database: ' + repr(self.database) + ' ' +\
6694            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6695            'healthy: ' + repr(self.healthy) + ' ' +\
6696            'hostname: ' + repr(self.hostname) + ' ' +\
6697            'id: ' + repr(self.id) + ' ' +\
6698            'name: ' + repr(self.name) + ' ' +\
6699            'password: ' + repr(self.password) + ' ' +\
6700            'port: ' + repr(self.port) + ' ' +\
6701            'port_override: ' + repr(self.port_override) + ' ' +\
6702            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6703            'tags: ' + repr(self.tags) + ' ' +\
6704            'username: ' + repr(self.username) + ' ' +\
6705            '>'
6706
6707    def to_dict(self):
6708        return {
6709            'bind_interface': self.bind_interface,
6710            'database': self.database,
6711            'egress_filter': self.egress_filter,
6712            'healthy': self.healthy,
6713            'hostname': self.hostname,
6714            'id': self.id,
6715            'name': self.name,
6716            'password': self.password,
6717            'port': self.port,
6718            'port_override': self.port_override,
6719            'secret_store_id': self.secret_store_id,
6720            'tags': self.tags,
6721            'username': self.username,
6722        }
6723
6724    @classmethod
6725    def from_dict(cls, d):
6726        return cls(
6727            bind_interface=d.get('bind_interface'),
6728            database=d.get('database'),
6729            egress_filter=d.get('egress_filter'),
6730            healthy=d.get('healthy'),
6731            hostname=d.get('hostname'),
6732            id=d.get('id'),
6733            name=d.get('name'),
6734            password=d.get('password'),
6735            port=d.get('port'),
6736            port_override=d.get('port_override'),
6737            secret_store_id=d.get('secret_store_id'),
6738            tags=d.get('tags'),
6739            username=d.get('username'),
6740        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6639    def __init__(
6640        self,
6641        bind_interface=None,
6642        database=None,
6643        egress_filter=None,
6644        healthy=None,
6645        hostname=None,
6646        id=None,
6647        name=None,
6648        password=None,
6649        port=None,
6650        port_override=None,
6651        secret_store_id=None,
6652        tags=None,
6653        username=None,
6654    ):
6655        self.bind_interface = bind_interface if bind_interface is not None else ''
6656        '''
6657         Bind interface
6658        '''
6659        self.database = database if database is not None else ''
6660        self.egress_filter = egress_filter if egress_filter is not None else ''
6661        '''
6662         A filter applied to the routing logic to pin datasource to nodes.
6663        '''
6664        self.healthy = healthy if healthy is not None else False
6665        '''
6666         True if the datasource is reachable and the credentials are valid.
6667        '''
6668        self.hostname = hostname if hostname is not None else ''
6669        self.id = id if id is not None else ''
6670        '''
6671         Unique identifier of the Resource.
6672        '''
6673        self.name = name if name is not None else ''
6674        '''
6675         Unique human-readable name of the Resource.
6676        '''
6677        self.password = password if password is not None else ''
6678        self.port = port if port is not None else 0
6679        self.port_override = port_override if port_override is not None else 0
6680        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6681        '''
6682         ID of the secret store containing credentials for this resource, if any.
6683        '''
6684        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6685        '''
6686         Tags is a map of key, value pairs.
6687        '''
6688        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6707    def to_dict(self):
6708        return {
6709            'bind_interface': self.bind_interface,
6710            'database': self.database,
6711            'egress_filter': self.egress_filter,
6712            'healthy': self.healthy,
6713            'hostname': self.hostname,
6714            'id': self.id,
6715            'name': self.name,
6716            'password': self.password,
6717            'port': self.port,
6718            'port_override': self.port_override,
6719            'secret_store_id': self.secret_store_id,
6720            'tags': self.tags,
6721            'username': self.username,
6722        }
@classmethod
def from_dict(cls, d)
6724    @classmethod
6725    def from_dict(cls, d):
6726        return cls(
6727            bind_interface=d.get('bind_interface'),
6728            database=d.get('database'),
6729            egress_filter=d.get('egress_filter'),
6730            healthy=d.get('healthy'),
6731            hostname=d.get('hostname'),
6732            id=d.get('id'),
6733            name=d.get('name'),
6734            password=d.get('password'),
6735            port=d.get('port'),
6736            port_override=d.get('port_override'),
6737            secret_store_id=d.get('secret_store_id'),
6738            tags=d.get('tags'),
6739            username=d.get('username'),
6740        )
class Memcached:
6743class Memcached:
6744    __slots__ = [
6745        'bind_interface',
6746        'egress_filter',
6747        'healthy',
6748        'hostname',
6749        'id',
6750        'name',
6751        'port',
6752        'port_override',
6753        'secret_store_id',
6754        'tags',
6755    ]
6756
6757    def __init__(
6758        self,
6759        bind_interface=None,
6760        egress_filter=None,
6761        healthy=None,
6762        hostname=None,
6763        id=None,
6764        name=None,
6765        port=None,
6766        port_override=None,
6767        secret_store_id=None,
6768        tags=None,
6769    ):
6770        self.bind_interface = bind_interface if bind_interface is not None else ''
6771        '''
6772         Bind interface
6773        '''
6774        self.egress_filter = egress_filter if egress_filter is not None else ''
6775        '''
6776         A filter applied to the routing logic to pin datasource to nodes.
6777        '''
6778        self.healthy = healthy if healthy is not None else False
6779        '''
6780         True if the datasource is reachable and the credentials are valid.
6781        '''
6782        self.hostname = hostname if hostname is not None else ''
6783        self.id = id if id is not None else ''
6784        '''
6785         Unique identifier of the Resource.
6786        '''
6787        self.name = name if name is not None else ''
6788        '''
6789         Unique human-readable name of the Resource.
6790        '''
6791        self.port = port if port is not None else 0
6792        self.port_override = port_override if port_override is not None else 0
6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6794        '''
6795         ID of the secret store containing credentials for this resource, if any.
6796        '''
6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6798        '''
6799         Tags is a map of key, value pairs.
6800        '''
6801
6802    def __repr__(self):
6803        return '<sdm.Memcached ' + \
6804            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6805            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6806            'healthy: ' + repr(self.healthy) + ' ' +\
6807            'hostname: ' + repr(self.hostname) + ' ' +\
6808            'id: ' + repr(self.id) + ' ' +\
6809            'name: ' + repr(self.name) + ' ' +\
6810            'port: ' + repr(self.port) + ' ' +\
6811            'port_override: ' + repr(self.port_override) + ' ' +\
6812            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6813            'tags: ' + repr(self.tags) + ' ' +\
6814            '>'
6815
6816    def to_dict(self):
6817        return {
6818            'bind_interface': self.bind_interface,
6819            'egress_filter': self.egress_filter,
6820            'healthy': self.healthy,
6821            'hostname': self.hostname,
6822            'id': self.id,
6823            'name': self.name,
6824            'port': self.port,
6825            'port_override': self.port_override,
6826            'secret_store_id': self.secret_store_id,
6827            'tags': self.tags,
6828        }
6829
6830    @classmethod
6831    def from_dict(cls, d):
6832        return cls(
6833            bind_interface=d.get('bind_interface'),
6834            egress_filter=d.get('egress_filter'),
6835            healthy=d.get('healthy'),
6836            hostname=d.get('hostname'),
6837            id=d.get('id'),
6838            name=d.get('name'),
6839            port=d.get('port'),
6840            port_override=d.get('port_override'),
6841            secret_store_id=d.get('secret_store_id'),
6842            tags=d.get('tags'),
6843        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6757    def __init__(
6758        self,
6759        bind_interface=None,
6760        egress_filter=None,
6761        healthy=None,
6762        hostname=None,
6763        id=None,
6764        name=None,
6765        port=None,
6766        port_override=None,
6767        secret_store_id=None,
6768        tags=None,
6769    ):
6770        self.bind_interface = bind_interface if bind_interface is not None else ''
6771        '''
6772         Bind interface
6773        '''
6774        self.egress_filter = egress_filter if egress_filter is not None else ''
6775        '''
6776         A filter applied to the routing logic to pin datasource to nodes.
6777        '''
6778        self.healthy = healthy if healthy is not None else False
6779        '''
6780         True if the datasource is reachable and the credentials are valid.
6781        '''
6782        self.hostname = hostname if hostname is not None else ''
6783        self.id = id if id is not None else ''
6784        '''
6785         Unique identifier of the Resource.
6786        '''
6787        self.name = name if name is not None else ''
6788        '''
6789         Unique human-readable name of the Resource.
6790        '''
6791        self.port = port if port is not None else 0
6792        self.port_override = port_override if port_override is not None else 0
6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6794        '''
6795         ID of the secret store containing credentials for this resource, if any.
6796        '''
6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6798        '''
6799         Tags is a map of key, value pairs.
6800        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6816    def to_dict(self):
6817        return {
6818            'bind_interface': self.bind_interface,
6819            'egress_filter': self.egress_filter,
6820            'healthy': self.healthy,
6821            'hostname': self.hostname,
6822            'id': self.id,
6823            'name': self.name,
6824            'port': self.port,
6825            'port_override': self.port_override,
6826            'secret_store_id': self.secret_store_id,
6827            'tags': self.tags,
6828        }
@classmethod
def from_dict(cls, d)
6830    @classmethod
6831    def from_dict(cls, d):
6832        return cls(
6833            bind_interface=d.get('bind_interface'),
6834            egress_filter=d.get('egress_filter'),
6835            healthy=d.get('healthy'),
6836            hostname=d.get('hostname'),
6837            id=d.get('id'),
6838            name=d.get('name'),
6839            port=d.get('port'),
6840            port_override=d.get('port_override'),
6841            secret_store_id=d.get('secret_store_id'),
6842            tags=d.get('tags'),
6843        )
class Memsql:
6846class Memsql:
6847    __slots__ = [
6848        'bind_interface',
6849        'database',
6850        'egress_filter',
6851        'healthy',
6852        'hostname',
6853        'id',
6854        'name',
6855        'password',
6856        'port',
6857        'port_override',
6858        'secret_store_id',
6859        'tags',
6860        'username',
6861    ]
6862
6863    def __init__(
6864        self,
6865        bind_interface=None,
6866        database=None,
6867        egress_filter=None,
6868        healthy=None,
6869        hostname=None,
6870        id=None,
6871        name=None,
6872        password=None,
6873        port=None,
6874        port_override=None,
6875        secret_store_id=None,
6876        tags=None,
6877        username=None,
6878    ):
6879        self.bind_interface = bind_interface if bind_interface is not None else ''
6880        '''
6881         Bind interface
6882        '''
6883        self.database = database if database is not None else ''
6884        self.egress_filter = egress_filter if egress_filter is not None else ''
6885        '''
6886         A filter applied to the routing logic to pin datasource to nodes.
6887        '''
6888        self.healthy = healthy if healthy is not None else False
6889        '''
6890         True if the datasource is reachable and the credentials are valid.
6891        '''
6892        self.hostname = hostname if hostname is not None else ''
6893        self.id = id if id is not None else ''
6894        '''
6895         Unique identifier of the Resource.
6896        '''
6897        self.name = name if name is not None else ''
6898        '''
6899         Unique human-readable name of the Resource.
6900        '''
6901        self.password = password if password is not None else ''
6902        self.port = port if port is not None else 0
6903        self.port_override = port_override if port_override is not None else 0
6904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6905        '''
6906         ID of the secret store containing credentials for this resource, if any.
6907        '''
6908        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6909        '''
6910         Tags is a map of key, value pairs.
6911        '''
6912        self.username = username if username is not None else ''
6913
6914    def __repr__(self):
6915        return '<sdm.Memsql ' + \
6916            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6917            'database: ' + repr(self.database) + ' ' +\
6918            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6919            'healthy: ' + repr(self.healthy) + ' ' +\
6920            'hostname: ' + repr(self.hostname) + ' ' +\
6921            'id: ' + repr(self.id) + ' ' +\
6922            'name: ' + repr(self.name) + ' ' +\
6923            'password: ' + repr(self.password) + ' ' +\
6924            'port: ' + repr(self.port) + ' ' +\
6925            'port_override: ' + repr(self.port_override) + ' ' +\
6926            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6927            'tags: ' + repr(self.tags) + ' ' +\
6928            'username: ' + repr(self.username) + ' ' +\
6929            '>'
6930
6931    def to_dict(self):
6932        return {
6933            'bind_interface': self.bind_interface,
6934            'database': self.database,
6935            'egress_filter': self.egress_filter,
6936            'healthy': self.healthy,
6937            'hostname': self.hostname,
6938            'id': self.id,
6939            'name': self.name,
6940            'password': self.password,
6941            'port': self.port,
6942            'port_override': self.port_override,
6943            'secret_store_id': self.secret_store_id,
6944            'tags': self.tags,
6945            'username': self.username,
6946        }
6947
6948    @classmethod
6949    def from_dict(cls, d):
6950        return cls(
6951            bind_interface=d.get('bind_interface'),
6952            database=d.get('database'),
6953            egress_filter=d.get('egress_filter'),
6954            healthy=d.get('healthy'),
6955            hostname=d.get('hostname'),
6956            id=d.get('id'),
6957            name=d.get('name'),
6958            password=d.get('password'),
6959            port=d.get('port'),
6960            port_override=d.get('port_override'),
6961            secret_store_id=d.get('secret_store_id'),
6962            tags=d.get('tags'),
6963            username=d.get('username'),
6964        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6863    def __init__(
6864        self,
6865        bind_interface=None,
6866        database=None,
6867        egress_filter=None,
6868        healthy=None,
6869        hostname=None,
6870        id=None,
6871        name=None,
6872        password=None,
6873        port=None,
6874        port_override=None,
6875        secret_store_id=None,
6876        tags=None,
6877        username=None,
6878    ):
6879        self.bind_interface = bind_interface if bind_interface is not None else ''
6880        '''
6881         Bind interface
6882        '''
6883        self.database = database if database is not None else ''
6884        self.egress_filter = egress_filter if egress_filter is not None else ''
6885        '''
6886         A filter applied to the routing logic to pin datasource to nodes.
6887        '''
6888        self.healthy = healthy if healthy is not None else False
6889        '''
6890         True if the datasource is reachable and the credentials are valid.
6891        '''
6892        self.hostname = hostname if hostname is not None else ''
6893        self.id = id if id is not None else ''
6894        '''
6895         Unique identifier of the Resource.
6896        '''
6897        self.name = name if name is not None else ''
6898        '''
6899         Unique human-readable name of the Resource.
6900        '''
6901        self.password = password if password is not None else ''
6902        self.port = port if port is not None else 0
6903        self.port_override = port_override if port_override is not None else 0
6904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6905        '''
6906         ID of the secret store containing credentials for this resource, if any.
6907        '''
6908        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6909        '''
6910         Tags is a map of key, value pairs.
6911        '''
6912        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6931    def to_dict(self):
6932        return {
6933            'bind_interface': self.bind_interface,
6934            'database': self.database,
6935            'egress_filter': self.egress_filter,
6936            'healthy': self.healthy,
6937            'hostname': self.hostname,
6938            'id': self.id,
6939            'name': self.name,
6940            'password': self.password,
6941            'port': self.port,
6942            'port_override': self.port_override,
6943            'secret_store_id': self.secret_store_id,
6944            'tags': self.tags,
6945            'username': self.username,
6946        }
@classmethod
def from_dict(cls, d)
6948    @classmethod
6949    def from_dict(cls, d):
6950        return cls(
6951            bind_interface=d.get('bind_interface'),
6952            database=d.get('database'),
6953            egress_filter=d.get('egress_filter'),
6954            healthy=d.get('healthy'),
6955            hostname=d.get('hostname'),
6956            id=d.get('id'),
6957            name=d.get('name'),
6958            password=d.get('password'),
6959            port=d.get('port'),
6960            port_override=d.get('port_override'),
6961            secret_store_id=d.get('secret_store_id'),
6962            tags=d.get('tags'),
6963            username=d.get('username'),
6964        )
class MongoHost:
6967class MongoHost:
6968    '''
6969    MongoHost is currently unstable, and its API may change, or it may be removed,
6970    without a major version bump.
6971    '''
6972    __slots__ = [
6973        'auth_database',
6974        'bind_interface',
6975        'egress_filter',
6976        'healthy',
6977        'hostname',
6978        'id',
6979        'name',
6980        'password',
6981        'port',
6982        'port_override',
6983        'secret_store_id',
6984        'tags',
6985        'tls_required',
6986        'username',
6987    ]
6988
6989    def __init__(
6990        self,
6991        auth_database=None,
6992        bind_interface=None,
6993        egress_filter=None,
6994        healthy=None,
6995        hostname=None,
6996        id=None,
6997        name=None,
6998        password=None,
6999        port=None,
7000        port_override=None,
7001        secret_store_id=None,
7002        tags=None,
7003        tls_required=None,
7004        username=None,
7005    ):
7006        self.auth_database = auth_database if auth_database is not None else ''
7007        self.bind_interface = bind_interface if bind_interface is not None else ''
7008        '''
7009         Bind interface
7010        '''
7011        self.egress_filter = egress_filter if egress_filter is not None else ''
7012        '''
7013         A filter applied to the routing logic to pin datasource to nodes.
7014        '''
7015        self.healthy = healthy if healthy is not None else False
7016        '''
7017         True if the datasource is reachable and the credentials are valid.
7018        '''
7019        self.hostname = hostname if hostname is not None else ''
7020        self.id = id if id is not None else ''
7021        '''
7022         Unique identifier of the Resource.
7023        '''
7024        self.name = name if name is not None else ''
7025        '''
7026         Unique human-readable name of the Resource.
7027        '''
7028        self.password = password if password is not None else ''
7029        self.port = port if port is not None else 0
7030        self.port_override = port_override if port_override is not None else 0
7031        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7032        '''
7033         ID of the secret store containing credentials for this resource, if any.
7034        '''
7035        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7036        '''
7037         Tags is a map of key, value pairs.
7038        '''
7039        self.tls_required = tls_required if tls_required is not None else False
7040        self.username = username if username is not None else ''
7041
7042    def __repr__(self):
7043        return '<sdm.MongoHost ' + \
7044            'auth_database: ' + repr(self.auth_database) + ' ' +\
7045            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7046            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7047            'healthy: ' + repr(self.healthy) + ' ' +\
7048            'hostname: ' + repr(self.hostname) + ' ' +\
7049            'id: ' + repr(self.id) + ' ' +\
7050            'name: ' + repr(self.name) + ' ' +\
7051            'password: ' + repr(self.password) + ' ' +\
7052            'port: ' + repr(self.port) + ' ' +\
7053            'port_override: ' + repr(self.port_override) + ' ' +\
7054            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7055            'tags: ' + repr(self.tags) + ' ' +\
7056            'tls_required: ' + repr(self.tls_required) + ' ' +\
7057            'username: ' + repr(self.username) + ' ' +\
7058            '>'
7059
7060    def to_dict(self):
7061        return {
7062            'auth_database': self.auth_database,
7063            'bind_interface': self.bind_interface,
7064            'egress_filter': self.egress_filter,
7065            'healthy': self.healthy,
7066            'hostname': self.hostname,
7067            'id': self.id,
7068            'name': self.name,
7069            'password': self.password,
7070            'port': self.port,
7071            'port_override': self.port_override,
7072            'secret_store_id': self.secret_store_id,
7073            'tags': self.tags,
7074            'tls_required': self.tls_required,
7075            'username': self.username,
7076        }
7077
7078    @classmethod
7079    def from_dict(cls, d):
7080        return cls(
7081            auth_database=d.get('auth_database'),
7082            bind_interface=d.get('bind_interface'),
7083            egress_filter=d.get('egress_filter'),
7084            healthy=d.get('healthy'),
7085            hostname=d.get('hostname'),
7086            id=d.get('id'),
7087            name=d.get('name'),
7088            password=d.get('password'),
7089            port=d.get('port'),
7090            port_override=d.get('port_override'),
7091            secret_store_id=d.get('secret_store_id'),
7092            tags=d.get('tags'),
7093            tls_required=d.get('tls_required'),
7094            username=d.get('username'),
7095        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
6989    def __init__(
6990        self,
6991        auth_database=None,
6992        bind_interface=None,
6993        egress_filter=None,
6994        healthy=None,
6995        hostname=None,
6996        id=None,
6997        name=None,
6998        password=None,
6999        port=None,
7000        port_override=None,
7001        secret_store_id=None,
7002        tags=None,
7003        tls_required=None,
7004        username=None,
7005    ):
7006        self.auth_database = auth_database if auth_database is not None else ''
7007        self.bind_interface = bind_interface if bind_interface is not None else ''
7008        '''
7009         Bind interface
7010        '''
7011        self.egress_filter = egress_filter if egress_filter is not None else ''
7012        '''
7013         A filter applied to the routing logic to pin datasource to nodes.
7014        '''
7015        self.healthy = healthy if healthy is not None else False
7016        '''
7017         True if the datasource is reachable and the credentials are valid.
7018        '''
7019        self.hostname = hostname if hostname is not None else ''
7020        self.id = id if id is not None else ''
7021        '''
7022         Unique identifier of the Resource.
7023        '''
7024        self.name = name if name is not None else ''
7025        '''
7026         Unique human-readable name of the Resource.
7027        '''
7028        self.password = password if password is not None else ''
7029        self.port = port if port is not None else 0
7030        self.port_override = port_override if port_override is not None else 0
7031        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7032        '''
7033         ID of the secret store containing credentials for this resource, if any.
7034        '''
7035        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7036        '''
7037         Tags is a map of key, value pairs.
7038        '''
7039        self.tls_required = tls_required if tls_required is not None else False
7040        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7060    def to_dict(self):
7061        return {
7062            'auth_database': self.auth_database,
7063            'bind_interface': self.bind_interface,
7064            'egress_filter': self.egress_filter,
7065            'healthy': self.healthy,
7066            'hostname': self.hostname,
7067            'id': self.id,
7068            'name': self.name,
7069            'password': self.password,
7070            'port': self.port,
7071            'port_override': self.port_override,
7072            'secret_store_id': self.secret_store_id,
7073            'tags': self.tags,
7074            'tls_required': self.tls_required,
7075            'username': self.username,
7076        }
@classmethod
def from_dict(cls, d)
7078    @classmethod
7079    def from_dict(cls, d):
7080        return cls(
7081            auth_database=d.get('auth_database'),
7082            bind_interface=d.get('bind_interface'),
7083            egress_filter=d.get('egress_filter'),
7084            healthy=d.get('healthy'),
7085            hostname=d.get('hostname'),
7086            id=d.get('id'),
7087            name=d.get('name'),
7088            password=d.get('password'),
7089            port=d.get('port'),
7090            port_override=d.get('port_override'),
7091            secret_store_id=d.get('secret_store_id'),
7092            tags=d.get('tags'),
7093            tls_required=d.get('tls_required'),
7094            username=d.get('username'),
7095        )
class MongoLegacyHost:
7098class MongoLegacyHost:
7099    __slots__ = [
7100        'auth_database',
7101        'bind_interface',
7102        'egress_filter',
7103        'healthy',
7104        'hostname',
7105        'id',
7106        'name',
7107        'password',
7108        'port',
7109        'port_override',
7110        'replica_set',
7111        'secret_store_id',
7112        'tags',
7113        'tls_required',
7114        'username',
7115    ]
7116
7117    def __init__(
7118        self,
7119        auth_database=None,
7120        bind_interface=None,
7121        egress_filter=None,
7122        healthy=None,
7123        hostname=None,
7124        id=None,
7125        name=None,
7126        password=None,
7127        port=None,
7128        port_override=None,
7129        replica_set=None,
7130        secret_store_id=None,
7131        tags=None,
7132        tls_required=None,
7133        username=None,
7134    ):
7135        self.auth_database = auth_database if auth_database is not None else ''
7136        self.bind_interface = bind_interface if bind_interface is not None else ''
7137        '''
7138         Bind interface
7139        '''
7140        self.egress_filter = egress_filter if egress_filter is not None else ''
7141        '''
7142         A filter applied to the routing logic to pin datasource to nodes.
7143        '''
7144        self.healthy = healthy if healthy is not None else False
7145        '''
7146         True if the datasource is reachable and the credentials are valid.
7147        '''
7148        self.hostname = hostname if hostname is not None else ''
7149        self.id = id if id is not None else ''
7150        '''
7151         Unique identifier of the Resource.
7152        '''
7153        self.name = name if name is not None else ''
7154        '''
7155         Unique human-readable name of the Resource.
7156        '''
7157        self.password = password if password is not None else ''
7158        self.port = port if port is not None else 0
7159        self.port_override = port_override if port_override is not None else 0
7160        self.replica_set = replica_set if replica_set is not None else ''
7161        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7162        '''
7163         ID of the secret store containing credentials for this resource, if any.
7164        '''
7165        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7166        '''
7167         Tags is a map of key, value pairs.
7168        '''
7169        self.tls_required = tls_required if tls_required is not None else False
7170        self.username = username if username is not None else ''
7171
7172    def __repr__(self):
7173        return '<sdm.MongoLegacyHost ' + \
7174            'auth_database: ' + repr(self.auth_database) + ' ' +\
7175            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7176            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7177            'healthy: ' + repr(self.healthy) + ' ' +\
7178            'hostname: ' + repr(self.hostname) + ' ' +\
7179            'id: ' + repr(self.id) + ' ' +\
7180            'name: ' + repr(self.name) + ' ' +\
7181            'password: ' + repr(self.password) + ' ' +\
7182            'port: ' + repr(self.port) + ' ' +\
7183            'port_override: ' + repr(self.port_override) + ' ' +\
7184            'replica_set: ' + repr(self.replica_set) + ' ' +\
7185            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7186            'tags: ' + repr(self.tags) + ' ' +\
7187            'tls_required: ' + repr(self.tls_required) + ' ' +\
7188            'username: ' + repr(self.username) + ' ' +\
7189            '>'
7190
7191    def to_dict(self):
7192        return {
7193            'auth_database': self.auth_database,
7194            'bind_interface': self.bind_interface,
7195            'egress_filter': self.egress_filter,
7196            'healthy': self.healthy,
7197            'hostname': self.hostname,
7198            'id': self.id,
7199            'name': self.name,
7200            'password': self.password,
7201            'port': self.port,
7202            'port_override': self.port_override,
7203            'replica_set': self.replica_set,
7204            'secret_store_id': self.secret_store_id,
7205            'tags': self.tags,
7206            'tls_required': self.tls_required,
7207            'username': self.username,
7208        }
7209
7210    @classmethod
7211    def from_dict(cls, d):
7212        return cls(
7213            auth_database=d.get('auth_database'),
7214            bind_interface=d.get('bind_interface'),
7215            egress_filter=d.get('egress_filter'),
7216            healthy=d.get('healthy'),
7217            hostname=d.get('hostname'),
7218            id=d.get('id'),
7219            name=d.get('name'),
7220            password=d.get('password'),
7221            port=d.get('port'),
7222            port_override=d.get('port_override'),
7223            replica_set=d.get('replica_set'),
7224            secret_store_id=d.get('secret_store_id'),
7225            tags=d.get('tags'),
7226            tls_required=d.get('tls_required'),
7227            username=d.get('username'),
7228        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7117    def __init__(
7118        self,
7119        auth_database=None,
7120        bind_interface=None,
7121        egress_filter=None,
7122        healthy=None,
7123        hostname=None,
7124        id=None,
7125        name=None,
7126        password=None,
7127        port=None,
7128        port_override=None,
7129        replica_set=None,
7130        secret_store_id=None,
7131        tags=None,
7132        tls_required=None,
7133        username=None,
7134    ):
7135        self.auth_database = auth_database if auth_database is not None else ''
7136        self.bind_interface = bind_interface if bind_interface is not None else ''
7137        '''
7138         Bind interface
7139        '''
7140        self.egress_filter = egress_filter if egress_filter is not None else ''
7141        '''
7142         A filter applied to the routing logic to pin datasource to nodes.
7143        '''
7144        self.healthy = healthy if healthy is not None else False
7145        '''
7146         True if the datasource is reachable and the credentials are valid.
7147        '''
7148        self.hostname = hostname if hostname is not None else ''
7149        self.id = id if id is not None else ''
7150        '''
7151         Unique identifier of the Resource.
7152        '''
7153        self.name = name if name is not None else ''
7154        '''
7155         Unique human-readable name of the Resource.
7156        '''
7157        self.password = password if password is not None else ''
7158        self.port = port if port is not None else 0
7159        self.port_override = port_override if port_override is not None else 0
7160        self.replica_set = replica_set if replica_set is not None else ''
7161        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7162        '''
7163         ID of the secret store containing credentials for this resource, if any.
7164        '''
7165        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7166        '''
7167         Tags is a map of key, value pairs.
7168        '''
7169        self.tls_required = tls_required if tls_required is not None else False
7170        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7191    def to_dict(self):
7192        return {
7193            'auth_database': self.auth_database,
7194            'bind_interface': self.bind_interface,
7195            'egress_filter': self.egress_filter,
7196            'healthy': self.healthy,
7197            'hostname': self.hostname,
7198            'id': self.id,
7199            'name': self.name,
7200            'password': self.password,
7201            'port': self.port,
7202            'port_override': self.port_override,
7203            'replica_set': self.replica_set,
7204            'secret_store_id': self.secret_store_id,
7205            'tags': self.tags,
7206            'tls_required': self.tls_required,
7207            'username': self.username,
7208        }
@classmethod
def from_dict(cls, d)
7210    @classmethod
7211    def from_dict(cls, d):
7212        return cls(
7213            auth_database=d.get('auth_database'),
7214            bind_interface=d.get('bind_interface'),
7215            egress_filter=d.get('egress_filter'),
7216            healthy=d.get('healthy'),
7217            hostname=d.get('hostname'),
7218            id=d.get('id'),
7219            name=d.get('name'),
7220            password=d.get('password'),
7221            port=d.get('port'),
7222            port_override=d.get('port_override'),
7223            replica_set=d.get('replica_set'),
7224            secret_store_id=d.get('secret_store_id'),
7225            tags=d.get('tags'),
7226            tls_required=d.get('tls_required'),
7227            username=d.get('username'),
7228        )
class MongoLegacyReplicaset:
7231class MongoLegacyReplicaset:
7232    __slots__ = [
7233        'auth_database',
7234        'bind_interface',
7235        'connect_to_replica',
7236        'egress_filter',
7237        'healthy',
7238        'hostname',
7239        'id',
7240        'name',
7241        'password',
7242        'port',
7243        'port_override',
7244        'replica_set',
7245        'secret_store_id',
7246        'tags',
7247        'tls_required',
7248        'username',
7249    ]
7250
7251    def __init__(
7252        self,
7253        auth_database=None,
7254        bind_interface=None,
7255        connect_to_replica=None,
7256        egress_filter=None,
7257        healthy=None,
7258        hostname=None,
7259        id=None,
7260        name=None,
7261        password=None,
7262        port=None,
7263        port_override=None,
7264        replica_set=None,
7265        secret_store_id=None,
7266        tags=None,
7267        tls_required=None,
7268        username=None,
7269    ):
7270        self.auth_database = auth_database if auth_database is not None else ''
7271        self.bind_interface = bind_interface if bind_interface is not None else ''
7272        '''
7273         Bind interface
7274        '''
7275        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7276        self.egress_filter = egress_filter if egress_filter is not None else ''
7277        '''
7278         A filter applied to the routing logic to pin datasource to nodes.
7279        '''
7280        self.healthy = healthy if healthy is not None else False
7281        '''
7282         True if the datasource is reachable and the credentials are valid.
7283        '''
7284        self.hostname = hostname if hostname is not None else ''
7285        self.id = id if id is not None else ''
7286        '''
7287         Unique identifier of the Resource.
7288        '''
7289        self.name = name if name is not None else ''
7290        '''
7291         Unique human-readable name of the Resource.
7292        '''
7293        self.password = password if password is not None else ''
7294        self.port = port if port is not None else 0
7295        self.port_override = port_override if port_override is not None else 0
7296        self.replica_set = replica_set if replica_set is not None else ''
7297        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7298        '''
7299         ID of the secret store containing credentials for this resource, if any.
7300        '''
7301        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7302        '''
7303         Tags is a map of key, value pairs.
7304        '''
7305        self.tls_required = tls_required if tls_required is not None else False
7306        self.username = username if username is not None else ''
7307
7308    def __repr__(self):
7309        return '<sdm.MongoLegacyReplicaset ' + \
7310            'auth_database: ' + repr(self.auth_database) + ' ' +\
7311            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7312            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7313            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7314            'healthy: ' + repr(self.healthy) + ' ' +\
7315            'hostname: ' + repr(self.hostname) + ' ' +\
7316            'id: ' + repr(self.id) + ' ' +\
7317            'name: ' + repr(self.name) + ' ' +\
7318            'password: ' + repr(self.password) + ' ' +\
7319            'port: ' + repr(self.port) + ' ' +\
7320            'port_override: ' + repr(self.port_override) + ' ' +\
7321            'replica_set: ' + repr(self.replica_set) + ' ' +\
7322            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7323            'tags: ' + repr(self.tags) + ' ' +\
7324            'tls_required: ' + repr(self.tls_required) + ' ' +\
7325            'username: ' + repr(self.username) + ' ' +\
7326            '>'
7327
7328    def to_dict(self):
7329        return {
7330            'auth_database': self.auth_database,
7331            'bind_interface': self.bind_interface,
7332            'connect_to_replica': self.connect_to_replica,
7333            'egress_filter': self.egress_filter,
7334            'healthy': self.healthy,
7335            'hostname': self.hostname,
7336            'id': self.id,
7337            'name': self.name,
7338            'password': self.password,
7339            'port': self.port,
7340            'port_override': self.port_override,
7341            'replica_set': self.replica_set,
7342            'secret_store_id': self.secret_store_id,
7343            'tags': self.tags,
7344            'tls_required': self.tls_required,
7345            'username': self.username,
7346        }
7347
7348    @classmethod
7349    def from_dict(cls, d):
7350        return cls(
7351            auth_database=d.get('auth_database'),
7352            bind_interface=d.get('bind_interface'),
7353            connect_to_replica=d.get('connect_to_replica'),
7354            egress_filter=d.get('egress_filter'),
7355            healthy=d.get('healthy'),
7356            hostname=d.get('hostname'),
7357            id=d.get('id'),
7358            name=d.get('name'),
7359            password=d.get('password'),
7360            port=d.get('port'),
7361            port_override=d.get('port_override'),
7362            replica_set=d.get('replica_set'),
7363            secret_store_id=d.get('secret_store_id'),
7364            tags=d.get('tags'),
7365            tls_required=d.get('tls_required'),
7366            username=d.get('username'),
7367        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7251    def __init__(
7252        self,
7253        auth_database=None,
7254        bind_interface=None,
7255        connect_to_replica=None,
7256        egress_filter=None,
7257        healthy=None,
7258        hostname=None,
7259        id=None,
7260        name=None,
7261        password=None,
7262        port=None,
7263        port_override=None,
7264        replica_set=None,
7265        secret_store_id=None,
7266        tags=None,
7267        tls_required=None,
7268        username=None,
7269    ):
7270        self.auth_database = auth_database if auth_database is not None else ''
7271        self.bind_interface = bind_interface if bind_interface is not None else ''
7272        '''
7273         Bind interface
7274        '''
7275        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7276        self.egress_filter = egress_filter if egress_filter is not None else ''
7277        '''
7278         A filter applied to the routing logic to pin datasource to nodes.
7279        '''
7280        self.healthy = healthy if healthy is not None else False
7281        '''
7282         True if the datasource is reachable and the credentials are valid.
7283        '''
7284        self.hostname = hostname if hostname is not None else ''
7285        self.id = id if id is not None else ''
7286        '''
7287         Unique identifier of the Resource.
7288        '''
7289        self.name = name if name is not None else ''
7290        '''
7291         Unique human-readable name of the Resource.
7292        '''
7293        self.password = password if password is not None else ''
7294        self.port = port if port is not None else 0
7295        self.port_override = port_override if port_override is not None else 0
7296        self.replica_set = replica_set if replica_set is not None else ''
7297        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7298        '''
7299         ID of the secret store containing credentials for this resource, if any.
7300        '''
7301        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7302        '''
7303         Tags is a map of key, value pairs.
7304        '''
7305        self.tls_required = tls_required if tls_required is not None else False
7306        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7328    def to_dict(self):
7329        return {
7330            'auth_database': self.auth_database,
7331            'bind_interface': self.bind_interface,
7332            'connect_to_replica': self.connect_to_replica,
7333            'egress_filter': self.egress_filter,
7334            'healthy': self.healthy,
7335            'hostname': self.hostname,
7336            'id': self.id,
7337            'name': self.name,
7338            'password': self.password,
7339            'port': self.port,
7340            'port_override': self.port_override,
7341            'replica_set': self.replica_set,
7342            'secret_store_id': self.secret_store_id,
7343            'tags': self.tags,
7344            'tls_required': self.tls_required,
7345            'username': self.username,
7346        }
@classmethod
def from_dict(cls, d)
7348    @classmethod
7349    def from_dict(cls, d):
7350        return cls(
7351            auth_database=d.get('auth_database'),
7352            bind_interface=d.get('bind_interface'),
7353            connect_to_replica=d.get('connect_to_replica'),
7354            egress_filter=d.get('egress_filter'),
7355            healthy=d.get('healthy'),
7356            hostname=d.get('hostname'),
7357            id=d.get('id'),
7358            name=d.get('name'),
7359            password=d.get('password'),
7360            port=d.get('port'),
7361            port_override=d.get('port_override'),
7362            replica_set=d.get('replica_set'),
7363            secret_store_id=d.get('secret_store_id'),
7364            tags=d.get('tags'),
7365            tls_required=d.get('tls_required'),
7366            username=d.get('username'),
7367        )
class MongoReplicaSet:
7370class MongoReplicaSet:
7371    '''
7372    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7373    without a major version bump.
7374    '''
7375    __slots__ = [
7376        'auth_database',
7377        'bind_interface',
7378        'connect_to_replica',
7379        'egress_filter',
7380        'healthy',
7381        'hostname',
7382        'id',
7383        'name',
7384        'password',
7385        'port',
7386        'port_override',
7387        'replica_set',
7388        'secret_store_id',
7389        'tags',
7390        'tls_required',
7391        'username',
7392    ]
7393
7394    def __init__(
7395        self,
7396        auth_database=None,
7397        bind_interface=None,
7398        connect_to_replica=None,
7399        egress_filter=None,
7400        healthy=None,
7401        hostname=None,
7402        id=None,
7403        name=None,
7404        password=None,
7405        port=None,
7406        port_override=None,
7407        replica_set=None,
7408        secret_store_id=None,
7409        tags=None,
7410        tls_required=None,
7411        username=None,
7412    ):
7413        self.auth_database = auth_database if auth_database is not None else ''
7414        self.bind_interface = bind_interface if bind_interface is not None else ''
7415        '''
7416         Bind interface
7417        '''
7418        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7419        self.egress_filter = egress_filter if egress_filter is not None else ''
7420        '''
7421         A filter applied to the routing logic to pin datasource to nodes.
7422        '''
7423        self.healthy = healthy if healthy is not None else False
7424        '''
7425         True if the datasource is reachable and the credentials are valid.
7426        '''
7427        self.hostname = hostname if hostname is not None else ''
7428        self.id = id if id is not None else ''
7429        '''
7430         Unique identifier of the Resource.
7431        '''
7432        self.name = name if name is not None else ''
7433        '''
7434         Unique human-readable name of the Resource.
7435        '''
7436        self.password = password if password is not None else ''
7437        self.port = port if port is not None else 0
7438        self.port_override = port_override if port_override is not None else 0
7439        self.replica_set = replica_set if replica_set is not None else ''
7440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7441        '''
7442         ID of the secret store containing credentials for this resource, if any.
7443        '''
7444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7445        '''
7446         Tags is a map of key, value pairs.
7447        '''
7448        self.tls_required = tls_required if tls_required is not None else False
7449        self.username = username if username is not None else ''
7450
7451    def __repr__(self):
7452        return '<sdm.MongoReplicaSet ' + \
7453            'auth_database: ' + repr(self.auth_database) + ' ' +\
7454            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7455            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7456            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7457            'healthy: ' + repr(self.healthy) + ' ' +\
7458            'hostname: ' + repr(self.hostname) + ' ' +\
7459            'id: ' + repr(self.id) + ' ' +\
7460            'name: ' + repr(self.name) + ' ' +\
7461            'password: ' + repr(self.password) + ' ' +\
7462            'port: ' + repr(self.port) + ' ' +\
7463            'port_override: ' + repr(self.port_override) + ' ' +\
7464            'replica_set: ' + repr(self.replica_set) + ' ' +\
7465            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7466            'tags: ' + repr(self.tags) + ' ' +\
7467            'tls_required: ' + repr(self.tls_required) + ' ' +\
7468            'username: ' + repr(self.username) + ' ' +\
7469            '>'
7470
7471    def to_dict(self):
7472        return {
7473            'auth_database': self.auth_database,
7474            'bind_interface': self.bind_interface,
7475            'connect_to_replica': self.connect_to_replica,
7476            'egress_filter': self.egress_filter,
7477            'healthy': self.healthy,
7478            'hostname': self.hostname,
7479            'id': self.id,
7480            'name': self.name,
7481            'password': self.password,
7482            'port': self.port,
7483            'port_override': self.port_override,
7484            'replica_set': self.replica_set,
7485            'secret_store_id': self.secret_store_id,
7486            'tags': self.tags,
7487            'tls_required': self.tls_required,
7488            'username': self.username,
7489        }
7490
7491    @classmethod
7492    def from_dict(cls, d):
7493        return cls(
7494            auth_database=d.get('auth_database'),
7495            bind_interface=d.get('bind_interface'),
7496            connect_to_replica=d.get('connect_to_replica'),
7497            egress_filter=d.get('egress_filter'),
7498            healthy=d.get('healthy'),
7499            hostname=d.get('hostname'),
7500            id=d.get('id'),
7501            name=d.get('name'),
7502            password=d.get('password'),
7503            port=d.get('port'),
7504            port_override=d.get('port_override'),
7505            replica_set=d.get('replica_set'),
7506            secret_store_id=d.get('secret_store_id'),
7507            tags=d.get('tags'),
7508            tls_required=d.get('tls_required'),
7509            username=d.get('username'),
7510        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7394    def __init__(
7395        self,
7396        auth_database=None,
7397        bind_interface=None,
7398        connect_to_replica=None,
7399        egress_filter=None,
7400        healthy=None,
7401        hostname=None,
7402        id=None,
7403        name=None,
7404        password=None,
7405        port=None,
7406        port_override=None,
7407        replica_set=None,
7408        secret_store_id=None,
7409        tags=None,
7410        tls_required=None,
7411        username=None,
7412    ):
7413        self.auth_database = auth_database if auth_database is not None else ''
7414        self.bind_interface = bind_interface if bind_interface is not None else ''
7415        '''
7416         Bind interface
7417        '''
7418        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7419        self.egress_filter = egress_filter if egress_filter is not None else ''
7420        '''
7421         A filter applied to the routing logic to pin datasource to nodes.
7422        '''
7423        self.healthy = healthy if healthy is not None else False
7424        '''
7425         True if the datasource is reachable and the credentials are valid.
7426        '''
7427        self.hostname = hostname if hostname is not None else ''
7428        self.id = id if id is not None else ''
7429        '''
7430         Unique identifier of the Resource.
7431        '''
7432        self.name = name if name is not None else ''
7433        '''
7434         Unique human-readable name of the Resource.
7435        '''
7436        self.password = password if password is not None else ''
7437        self.port = port if port is not None else 0
7438        self.port_override = port_override if port_override is not None else 0
7439        self.replica_set = replica_set if replica_set is not None else ''
7440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7441        '''
7442         ID of the secret store containing credentials for this resource, if any.
7443        '''
7444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7445        '''
7446         Tags is a map of key, value pairs.
7447        '''
7448        self.tls_required = tls_required if tls_required is not None else False
7449        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7471    def to_dict(self):
7472        return {
7473            'auth_database': self.auth_database,
7474            'bind_interface': self.bind_interface,
7475            'connect_to_replica': self.connect_to_replica,
7476            'egress_filter': self.egress_filter,
7477            'healthy': self.healthy,
7478            'hostname': self.hostname,
7479            'id': self.id,
7480            'name': self.name,
7481            'password': self.password,
7482            'port': self.port,
7483            'port_override': self.port_override,
7484            'replica_set': self.replica_set,
7485            'secret_store_id': self.secret_store_id,
7486            'tags': self.tags,
7487            'tls_required': self.tls_required,
7488            'username': self.username,
7489        }
@classmethod
def from_dict(cls, d)
7491    @classmethod
7492    def from_dict(cls, d):
7493        return cls(
7494            auth_database=d.get('auth_database'),
7495            bind_interface=d.get('bind_interface'),
7496            connect_to_replica=d.get('connect_to_replica'),
7497            egress_filter=d.get('egress_filter'),
7498            healthy=d.get('healthy'),
7499            hostname=d.get('hostname'),
7500            id=d.get('id'),
7501            name=d.get('name'),
7502            password=d.get('password'),
7503            port=d.get('port'),
7504            port_override=d.get('port_override'),
7505            replica_set=d.get('replica_set'),
7506            secret_store_id=d.get('secret_store_id'),
7507            tags=d.get('tags'),
7508            tls_required=d.get('tls_required'),
7509            username=d.get('username'),
7510        )
class MongoShardedCluster:
7513class MongoShardedCluster:
7514    '''
7515    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
7516    without a major version bump.
7517    '''
7518    __slots__ = [
7519        'auth_database',
7520        'bind_interface',
7521        'egress_filter',
7522        'healthy',
7523        'hostname',
7524        'id',
7525        'name',
7526        'password',
7527        'port_override',
7528        'secret_store_id',
7529        'tags',
7530        'tls_required',
7531        'username',
7532    ]
7533
7534    def __init__(
7535        self,
7536        auth_database=None,
7537        bind_interface=None,
7538        egress_filter=None,
7539        healthy=None,
7540        hostname=None,
7541        id=None,
7542        name=None,
7543        password=None,
7544        port_override=None,
7545        secret_store_id=None,
7546        tags=None,
7547        tls_required=None,
7548        username=None,
7549    ):
7550        self.auth_database = auth_database if auth_database is not None else ''
7551        self.bind_interface = bind_interface if bind_interface is not None else ''
7552        '''
7553         Bind interface
7554        '''
7555        self.egress_filter = egress_filter if egress_filter is not None else ''
7556        '''
7557         A filter applied to the routing logic to pin datasource to nodes.
7558        '''
7559        self.healthy = healthy if healthy is not None else False
7560        '''
7561         True if the datasource is reachable and the credentials are valid.
7562        '''
7563        self.hostname = hostname if hostname is not None else ''
7564        self.id = id if id is not None else ''
7565        '''
7566         Unique identifier of the Resource.
7567        '''
7568        self.name = name if name is not None else ''
7569        '''
7570         Unique human-readable name of the Resource.
7571        '''
7572        self.password = password if password is not None else ''
7573        self.port_override = port_override if port_override is not None else 0
7574        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7575        '''
7576         ID of the secret store containing credentials for this resource, if any.
7577        '''
7578        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7579        '''
7580         Tags is a map of key, value pairs.
7581        '''
7582        self.tls_required = tls_required if tls_required is not None else False
7583        self.username = username if username is not None else ''
7584
7585    def __repr__(self):
7586        return '<sdm.MongoShardedCluster ' + \
7587            'auth_database: ' + repr(self.auth_database) + ' ' +\
7588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7589            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7590            'healthy: ' + repr(self.healthy) + ' ' +\
7591            'hostname: ' + repr(self.hostname) + ' ' +\
7592            'id: ' + repr(self.id) + ' ' +\
7593            'name: ' + repr(self.name) + ' ' +\
7594            'password: ' + repr(self.password) + ' ' +\
7595            'port_override: ' + repr(self.port_override) + ' ' +\
7596            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7597            'tags: ' + repr(self.tags) + ' ' +\
7598            'tls_required: ' + repr(self.tls_required) + ' ' +\
7599            'username: ' + repr(self.username) + ' ' +\
7600            '>'
7601
7602    def to_dict(self):
7603        return {
7604            'auth_database': self.auth_database,
7605            'bind_interface': self.bind_interface,
7606            'egress_filter': self.egress_filter,
7607            'healthy': self.healthy,
7608            'hostname': self.hostname,
7609            'id': self.id,
7610            'name': self.name,
7611            'password': self.password,
7612            'port_override': self.port_override,
7613            'secret_store_id': self.secret_store_id,
7614            'tags': self.tags,
7615            'tls_required': self.tls_required,
7616            'username': self.username,
7617        }
7618
7619    @classmethod
7620    def from_dict(cls, d):
7621        return cls(
7622            auth_database=d.get('auth_database'),
7623            bind_interface=d.get('bind_interface'),
7624            egress_filter=d.get('egress_filter'),
7625            healthy=d.get('healthy'),
7626            hostname=d.get('hostname'),
7627            id=d.get('id'),
7628            name=d.get('name'),
7629            password=d.get('password'),
7630            port_override=d.get('port_override'),
7631            secret_store_id=d.get('secret_store_id'),
7632            tags=d.get('tags'),
7633            tls_required=d.get('tls_required'),
7634            username=d.get('username'),
7635        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7534    def __init__(
7535        self,
7536        auth_database=None,
7537        bind_interface=None,
7538        egress_filter=None,
7539        healthy=None,
7540        hostname=None,
7541        id=None,
7542        name=None,
7543        password=None,
7544        port_override=None,
7545        secret_store_id=None,
7546        tags=None,
7547        tls_required=None,
7548        username=None,
7549    ):
7550        self.auth_database = auth_database if auth_database is not None else ''
7551        self.bind_interface = bind_interface if bind_interface is not None else ''
7552        '''
7553         Bind interface
7554        '''
7555        self.egress_filter = egress_filter if egress_filter is not None else ''
7556        '''
7557         A filter applied to the routing logic to pin datasource to nodes.
7558        '''
7559        self.healthy = healthy if healthy is not None else False
7560        '''
7561         True if the datasource is reachable and the credentials are valid.
7562        '''
7563        self.hostname = hostname if hostname is not None else ''
7564        self.id = id if id is not None else ''
7565        '''
7566         Unique identifier of the Resource.
7567        '''
7568        self.name = name if name is not None else ''
7569        '''
7570         Unique human-readable name of the Resource.
7571        '''
7572        self.password = password if password is not None else ''
7573        self.port_override = port_override if port_override is not None else 0
7574        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7575        '''
7576         ID of the secret store containing credentials for this resource, if any.
7577        '''
7578        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7579        '''
7580         Tags is a map of key, value pairs.
7581        '''
7582        self.tls_required = tls_required if tls_required is not None else False
7583        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7602    def to_dict(self):
7603        return {
7604            'auth_database': self.auth_database,
7605            'bind_interface': self.bind_interface,
7606            'egress_filter': self.egress_filter,
7607            'healthy': self.healthy,
7608            'hostname': self.hostname,
7609            'id': self.id,
7610            'name': self.name,
7611            'password': self.password,
7612            'port_override': self.port_override,
7613            'secret_store_id': self.secret_store_id,
7614            'tags': self.tags,
7615            'tls_required': self.tls_required,
7616            'username': self.username,
7617        }
@classmethod
def from_dict(cls, d)
7619    @classmethod
7620    def from_dict(cls, d):
7621        return cls(
7622            auth_database=d.get('auth_database'),
7623            bind_interface=d.get('bind_interface'),
7624            egress_filter=d.get('egress_filter'),
7625            healthy=d.get('healthy'),
7626            hostname=d.get('hostname'),
7627            id=d.get('id'),
7628            name=d.get('name'),
7629            password=d.get('password'),
7630            port_override=d.get('port_override'),
7631            secret_store_id=d.get('secret_store_id'),
7632            tags=d.get('tags'),
7633            tls_required=d.get('tls_required'),
7634            username=d.get('username'),
7635        )
class Mysql:
7638class Mysql:
7639    __slots__ = [
7640        'bind_interface',
7641        'database',
7642        'egress_filter',
7643        'healthy',
7644        'hostname',
7645        'id',
7646        'name',
7647        'password',
7648        'port',
7649        'port_override',
7650        'secret_store_id',
7651        'tags',
7652        'username',
7653    ]
7654
7655    def __init__(
7656        self,
7657        bind_interface=None,
7658        database=None,
7659        egress_filter=None,
7660        healthy=None,
7661        hostname=None,
7662        id=None,
7663        name=None,
7664        password=None,
7665        port=None,
7666        port_override=None,
7667        secret_store_id=None,
7668        tags=None,
7669        username=None,
7670    ):
7671        self.bind_interface = bind_interface if bind_interface is not None else ''
7672        '''
7673         Bind interface
7674        '''
7675        self.database = database if database is not None else ''
7676        self.egress_filter = egress_filter if egress_filter is not None else ''
7677        '''
7678         A filter applied to the routing logic to pin datasource to nodes.
7679        '''
7680        self.healthy = healthy if healthy is not None else False
7681        '''
7682         True if the datasource is reachable and the credentials are valid.
7683        '''
7684        self.hostname = hostname if hostname is not None else ''
7685        self.id = id if id is not None else ''
7686        '''
7687         Unique identifier of the Resource.
7688        '''
7689        self.name = name if name is not None else ''
7690        '''
7691         Unique human-readable name of the Resource.
7692        '''
7693        self.password = password if password is not None else ''
7694        self.port = port if port is not None else 0
7695        self.port_override = port_override if port_override is not None else 0
7696        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7697        '''
7698         ID of the secret store containing credentials for this resource, if any.
7699        '''
7700        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7701        '''
7702         Tags is a map of key, value pairs.
7703        '''
7704        self.username = username if username is not None else ''
7705
7706    def __repr__(self):
7707        return '<sdm.Mysql ' + \
7708            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7709            'database: ' + repr(self.database) + ' ' +\
7710            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7711            'healthy: ' + repr(self.healthy) + ' ' +\
7712            'hostname: ' + repr(self.hostname) + ' ' +\
7713            'id: ' + repr(self.id) + ' ' +\
7714            'name: ' + repr(self.name) + ' ' +\
7715            'password: ' + repr(self.password) + ' ' +\
7716            'port: ' + repr(self.port) + ' ' +\
7717            'port_override: ' + repr(self.port_override) + ' ' +\
7718            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7719            'tags: ' + repr(self.tags) + ' ' +\
7720            'username: ' + repr(self.username) + ' ' +\
7721            '>'
7722
7723    def to_dict(self):
7724        return {
7725            'bind_interface': self.bind_interface,
7726            'database': self.database,
7727            'egress_filter': self.egress_filter,
7728            'healthy': self.healthy,
7729            'hostname': self.hostname,
7730            'id': self.id,
7731            'name': self.name,
7732            'password': self.password,
7733            'port': self.port,
7734            'port_override': self.port_override,
7735            'secret_store_id': self.secret_store_id,
7736            'tags': self.tags,
7737            'username': self.username,
7738        }
7739
7740    @classmethod
7741    def from_dict(cls, d):
7742        return cls(
7743            bind_interface=d.get('bind_interface'),
7744            database=d.get('database'),
7745            egress_filter=d.get('egress_filter'),
7746            healthy=d.get('healthy'),
7747            hostname=d.get('hostname'),
7748            id=d.get('id'),
7749            name=d.get('name'),
7750            password=d.get('password'),
7751            port=d.get('port'),
7752            port_override=d.get('port_override'),
7753            secret_store_id=d.get('secret_store_id'),
7754            tags=d.get('tags'),
7755            username=d.get('username'),
7756        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7655    def __init__(
7656        self,
7657        bind_interface=None,
7658        database=None,
7659        egress_filter=None,
7660        healthy=None,
7661        hostname=None,
7662        id=None,
7663        name=None,
7664        password=None,
7665        port=None,
7666        port_override=None,
7667        secret_store_id=None,
7668        tags=None,
7669        username=None,
7670    ):
7671        self.bind_interface = bind_interface if bind_interface is not None else ''
7672        '''
7673         Bind interface
7674        '''
7675        self.database = database if database is not None else ''
7676        self.egress_filter = egress_filter if egress_filter is not None else ''
7677        '''
7678         A filter applied to the routing logic to pin datasource to nodes.
7679        '''
7680        self.healthy = healthy if healthy is not None else False
7681        '''
7682         True if the datasource is reachable and the credentials are valid.
7683        '''
7684        self.hostname = hostname if hostname is not None else ''
7685        self.id = id if id is not None else ''
7686        '''
7687         Unique identifier of the Resource.
7688        '''
7689        self.name = name if name is not None else ''
7690        '''
7691         Unique human-readable name of the Resource.
7692        '''
7693        self.password = password if password is not None else ''
7694        self.port = port if port is not None else 0
7695        self.port_override = port_override if port_override is not None else 0
7696        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7697        '''
7698         ID of the secret store containing credentials for this resource, if any.
7699        '''
7700        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7701        '''
7702         Tags is a map of key, value pairs.
7703        '''
7704        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7723    def to_dict(self):
7724        return {
7725            'bind_interface': self.bind_interface,
7726            'database': self.database,
7727            'egress_filter': self.egress_filter,
7728            'healthy': self.healthy,
7729            'hostname': self.hostname,
7730            'id': self.id,
7731            'name': self.name,
7732            'password': self.password,
7733            'port': self.port,
7734            'port_override': self.port_override,
7735            'secret_store_id': self.secret_store_id,
7736            'tags': self.tags,
7737            'username': self.username,
7738        }
@classmethod
def from_dict(cls, d)
7740    @classmethod
7741    def from_dict(cls, d):
7742        return cls(
7743            bind_interface=d.get('bind_interface'),
7744            database=d.get('database'),
7745            egress_filter=d.get('egress_filter'),
7746            healthy=d.get('healthy'),
7747            hostname=d.get('hostname'),
7748            id=d.get('id'),
7749            name=d.get('name'),
7750            password=d.get('password'),
7751            port=d.get('port'),
7752            port_override=d.get('port_override'),
7753            secret_store_id=d.get('secret_store_id'),
7754            tags=d.get('tags'),
7755            username=d.get('username'),
7756        )
class Neptune:
7759class Neptune:
7760    __slots__ = [
7761        'bind_interface',
7762        'egress_filter',
7763        'endpoint',
7764        'healthy',
7765        'id',
7766        'name',
7767        'port',
7768        'port_override',
7769        'secret_store_id',
7770        'tags',
7771    ]
7772
7773    def __init__(
7774        self,
7775        bind_interface=None,
7776        egress_filter=None,
7777        endpoint=None,
7778        healthy=None,
7779        id=None,
7780        name=None,
7781        port=None,
7782        port_override=None,
7783        secret_store_id=None,
7784        tags=None,
7785    ):
7786        self.bind_interface = bind_interface if bind_interface is not None else ''
7787        '''
7788         Bind interface
7789        '''
7790        self.egress_filter = egress_filter if egress_filter is not None else ''
7791        '''
7792         A filter applied to the routing logic to pin datasource to nodes.
7793        '''
7794        self.endpoint = endpoint if endpoint is not None else ''
7795        self.healthy = healthy if healthy is not None else False
7796        '''
7797         True if the datasource is reachable and the credentials are valid.
7798        '''
7799        self.id = id if id is not None else ''
7800        '''
7801         Unique identifier of the Resource.
7802        '''
7803        self.name = name if name is not None else ''
7804        '''
7805         Unique human-readable name of the Resource.
7806        '''
7807        self.port = port if port is not None else 0
7808        self.port_override = port_override if port_override is not None else 0
7809        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7810        '''
7811         ID of the secret store containing credentials for this resource, if any.
7812        '''
7813        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7814        '''
7815         Tags is a map of key, value pairs.
7816        '''
7817
7818    def __repr__(self):
7819        return '<sdm.Neptune ' + \
7820            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7821            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7822            'endpoint: ' + repr(self.endpoint) + ' ' +\
7823            'healthy: ' + repr(self.healthy) + ' ' +\
7824            'id: ' + repr(self.id) + ' ' +\
7825            'name: ' + repr(self.name) + ' ' +\
7826            'port: ' + repr(self.port) + ' ' +\
7827            'port_override: ' + repr(self.port_override) + ' ' +\
7828            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7829            'tags: ' + repr(self.tags) + ' ' +\
7830            '>'
7831
7832    def to_dict(self):
7833        return {
7834            'bind_interface': self.bind_interface,
7835            'egress_filter': self.egress_filter,
7836            'endpoint': self.endpoint,
7837            'healthy': self.healthy,
7838            'id': self.id,
7839            'name': self.name,
7840            'port': self.port,
7841            'port_override': self.port_override,
7842            'secret_store_id': self.secret_store_id,
7843            'tags': self.tags,
7844        }
7845
7846    @classmethod
7847    def from_dict(cls, d):
7848        return cls(
7849            bind_interface=d.get('bind_interface'),
7850            egress_filter=d.get('egress_filter'),
7851            endpoint=d.get('endpoint'),
7852            healthy=d.get('healthy'),
7853            id=d.get('id'),
7854            name=d.get('name'),
7855            port=d.get('port'),
7856            port_override=d.get('port_override'),
7857            secret_store_id=d.get('secret_store_id'),
7858            tags=d.get('tags'),
7859        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7773    def __init__(
7774        self,
7775        bind_interface=None,
7776        egress_filter=None,
7777        endpoint=None,
7778        healthy=None,
7779        id=None,
7780        name=None,
7781        port=None,
7782        port_override=None,
7783        secret_store_id=None,
7784        tags=None,
7785    ):
7786        self.bind_interface = bind_interface if bind_interface is not None else ''
7787        '''
7788         Bind interface
7789        '''
7790        self.egress_filter = egress_filter if egress_filter is not None else ''
7791        '''
7792         A filter applied to the routing logic to pin datasource to nodes.
7793        '''
7794        self.endpoint = endpoint if endpoint is not None else ''
7795        self.healthy = healthy if healthy is not None else False
7796        '''
7797         True if the datasource is reachable and the credentials are valid.
7798        '''
7799        self.id = id if id is not None else ''
7800        '''
7801         Unique identifier of the Resource.
7802        '''
7803        self.name = name if name is not None else ''
7804        '''
7805         Unique human-readable name of the Resource.
7806        '''
7807        self.port = port if port is not None else 0
7808        self.port_override = port_override if port_override is not None else 0
7809        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7810        '''
7811         ID of the secret store containing credentials for this resource, if any.
7812        '''
7813        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7814        '''
7815         Tags is a map of key, value pairs.
7816        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7832    def to_dict(self):
7833        return {
7834            'bind_interface': self.bind_interface,
7835            'egress_filter': self.egress_filter,
7836            'endpoint': self.endpoint,
7837            'healthy': self.healthy,
7838            'id': self.id,
7839            'name': self.name,
7840            'port': self.port,
7841            'port_override': self.port_override,
7842            'secret_store_id': self.secret_store_id,
7843            'tags': self.tags,
7844        }
@classmethod
def from_dict(cls, d)
7846    @classmethod
7847    def from_dict(cls, d):
7848        return cls(
7849            bind_interface=d.get('bind_interface'),
7850            egress_filter=d.get('egress_filter'),
7851            endpoint=d.get('endpoint'),
7852            healthy=d.get('healthy'),
7853            id=d.get('id'),
7854            name=d.get('name'),
7855            port=d.get('port'),
7856            port_override=d.get('port_override'),
7857            secret_store_id=d.get('secret_store_id'),
7858            tags=d.get('tags'),
7859        )
class NeptuneIAM:
7862class NeptuneIAM:
7863    __slots__ = [
7864        'access_key',
7865        'bind_interface',
7866        'egress_filter',
7867        'endpoint',
7868        'healthy',
7869        'id',
7870        'name',
7871        'port',
7872        'port_override',
7873        'region',
7874        'role_arn',
7875        'role_external_id',
7876        'secret_access_key',
7877        'secret_store_id',
7878        'tags',
7879    ]
7880
7881    def __init__(
7882        self,
7883        access_key=None,
7884        bind_interface=None,
7885        egress_filter=None,
7886        endpoint=None,
7887        healthy=None,
7888        id=None,
7889        name=None,
7890        port=None,
7891        port_override=None,
7892        region=None,
7893        role_arn=None,
7894        role_external_id=None,
7895        secret_access_key=None,
7896        secret_store_id=None,
7897        tags=None,
7898    ):
7899        self.access_key = access_key if access_key is not None else ''
7900        self.bind_interface = bind_interface if bind_interface is not None else ''
7901        '''
7902         Bind interface
7903        '''
7904        self.egress_filter = egress_filter if egress_filter is not None else ''
7905        '''
7906         A filter applied to the routing logic to pin datasource to nodes.
7907        '''
7908        self.endpoint = endpoint if endpoint is not None else ''
7909        self.healthy = healthy if healthy is not None else False
7910        '''
7911         True if the datasource is reachable and the credentials are valid.
7912        '''
7913        self.id = id if id is not None else ''
7914        '''
7915         Unique identifier of the Resource.
7916        '''
7917        self.name = name if name is not None else ''
7918        '''
7919         Unique human-readable name of the Resource.
7920        '''
7921        self.port = port if port is not None else 0
7922        self.port_override = port_override if port_override is not None else 0
7923        self.region = region if region is not None else ''
7924        self.role_arn = role_arn if role_arn is not None else ''
7925        self.role_external_id = role_external_id if role_external_id is not None else ''
7926        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
7927        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7928        '''
7929         ID of the secret store containing credentials for this resource, if any.
7930        '''
7931        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7932        '''
7933         Tags is a map of key, value pairs.
7934        '''
7935
7936    def __repr__(self):
7937        return '<sdm.NeptuneIAM ' + \
7938            'access_key: ' + repr(self.access_key) + ' ' +\
7939            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7940            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7941            'endpoint: ' + repr(self.endpoint) + ' ' +\
7942            'healthy: ' + repr(self.healthy) + ' ' +\
7943            'id: ' + repr(self.id) + ' ' +\
7944            'name: ' + repr(self.name) + ' ' +\
7945            'port: ' + repr(self.port) + ' ' +\
7946            'port_override: ' + repr(self.port_override) + ' ' +\
7947            'region: ' + repr(self.region) + ' ' +\
7948            'role_arn: ' + repr(self.role_arn) + ' ' +\
7949            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
7950            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
7951            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7952            'tags: ' + repr(self.tags) + ' ' +\
7953            '>'
7954
7955    def to_dict(self):
7956        return {
7957            'access_key': self.access_key,
7958            'bind_interface': self.bind_interface,
7959            'egress_filter': self.egress_filter,
7960            'endpoint': self.endpoint,
7961            'healthy': self.healthy,
7962            'id': self.id,
7963            'name': self.name,
7964            'port': self.port,
7965            'port_override': self.port_override,
7966            'region': self.region,
7967            'role_arn': self.role_arn,
7968            'role_external_id': self.role_external_id,
7969            'secret_access_key': self.secret_access_key,
7970            'secret_store_id': self.secret_store_id,
7971            'tags': self.tags,
7972        }
7973
7974    @classmethod
7975    def from_dict(cls, d):
7976        return cls(
7977            access_key=d.get('access_key'),
7978            bind_interface=d.get('bind_interface'),
7979            egress_filter=d.get('egress_filter'),
7980            endpoint=d.get('endpoint'),
7981            healthy=d.get('healthy'),
7982            id=d.get('id'),
7983            name=d.get('name'),
7984            port=d.get('port'),
7985            port_override=d.get('port_override'),
7986            region=d.get('region'),
7987            role_arn=d.get('role_arn'),
7988            role_external_id=d.get('role_external_id'),
7989            secret_access_key=d.get('secret_access_key'),
7990            secret_store_id=d.get('secret_store_id'),
7991            tags=d.get('tags'),
7992        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
7881    def __init__(
7882        self,
7883        access_key=None,
7884        bind_interface=None,
7885        egress_filter=None,
7886        endpoint=None,
7887        healthy=None,
7888        id=None,
7889        name=None,
7890        port=None,
7891        port_override=None,
7892        region=None,
7893        role_arn=None,
7894        role_external_id=None,
7895        secret_access_key=None,
7896        secret_store_id=None,
7897        tags=None,
7898    ):
7899        self.access_key = access_key if access_key is not None else ''
7900        self.bind_interface = bind_interface if bind_interface is not None else ''
7901        '''
7902         Bind interface
7903        '''
7904        self.egress_filter = egress_filter if egress_filter is not None else ''
7905        '''
7906         A filter applied to the routing logic to pin datasource to nodes.
7907        '''
7908        self.endpoint = endpoint if endpoint is not None else ''
7909        self.healthy = healthy if healthy is not None else False
7910        '''
7911         True if the datasource is reachable and the credentials are valid.
7912        '''
7913        self.id = id if id is not None else ''
7914        '''
7915         Unique identifier of the Resource.
7916        '''
7917        self.name = name if name is not None else ''
7918        '''
7919         Unique human-readable name of the Resource.
7920        '''
7921        self.port = port if port is not None else 0
7922        self.port_override = port_override if port_override is not None else 0
7923        self.region = region if region is not None else ''
7924        self.role_arn = role_arn if role_arn is not None else ''
7925        self.role_external_id = role_external_id if role_external_id is not None else ''
7926        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
7927        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7928        '''
7929         ID of the secret store containing credentials for this resource, if any.
7930        '''
7931        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7932        '''
7933         Tags is a map of key, value pairs.
7934        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7955    def to_dict(self):
7956        return {
7957            'access_key': self.access_key,
7958            'bind_interface': self.bind_interface,
7959            'egress_filter': self.egress_filter,
7960            'endpoint': self.endpoint,
7961            'healthy': self.healthy,
7962            'id': self.id,
7963            'name': self.name,
7964            'port': self.port,
7965            'port_override': self.port_override,
7966            'region': self.region,
7967            'role_arn': self.role_arn,
7968            'role_external_id': self.role_external_id,
7969            'secret_access_key': self.secret_access_key,
7970            'secret_store_id': self.secret_store_id,
7971            'tags': self.tags,
7972        }
@classmethod
def from_dict(cls, d)
7974    @classmethod
7975    def from_dict(cls, d):
7976        return cls(
7977            access_key=d.get('access_key'),
7978            bind_interface=d.get('bind_interface'),
7979            egress_filter=d.get('egress_filter'),
7980            endpoint=d.get('endpoint'),
7981            healthy=d.get('healthy'),
7982            id=d.get('id'),
7983            name=d.get('name'),
7984            port=d.get('port'),
7985            port_override=d.get('port_override'),
7986            region=d.get('region'),
7987            role_arn=d.get('role_arn'),
7988            role_external_id=d.get('role_external_id'),
7989            secret_access_key=d.get('secret_access_key'),
7990            secret_store_id=d.get('secret_store_id'),
7991            tags=d.get('tags'),
7992        )
class NodeCreateResponse:
7995class NodeCreateResponse:
7996    '''
7997         NodeCreateResponse reports how the Nodes were created in the system.
7998    '''
7999    __slots__ = [
8000        'meta',
8001        'node',
8002        'rate_limit',
8003        'token',
8004    ]
8005
8006    def __init__(
8007        self,
8008        meta=None,
8009        node=None,
8010        rate_limit=None,
8011        token=None,
8012    ):
8013        self.meta = meta if meta is not None else None
8014        '''
8015         Reserved for future use.
8016        '''
8017        self.node = node if node is not None else None
8018        '''
8019         The created Node.
8020        '''
8021        self.rate_limit = rate_limit if rate_limit is not None else None
8022        '''
8023         Rate limit information.
8024        '''
8025        self.token = token if token is not None else ''
8026        '''
8027         The auth token generated for the Node. The Node will use this token to
8028         authenticate with the strongDM API.
8029        '''
8030
8031    def __repr__(self):
8032        return '<sdm.NodeCreateResponse ' + \
8033            'meta: ' + repr(self.meta) + ' ' +\
8034            'node: ' + repr(self.node) + ' ' +\
8035            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8036            'token: ' + repr(self.token) + ' ' +\
8037            '>'
8038
8039    def to_dict(self):
8040        return {
8041            'meta': self.meta,
8042            'node': self.node,
8043            'rate_limit': self.rate_limit,
8044            'token': self.token,
8045        }
8046
8047    @classmethod
8048    def from_dict(cls, d):
8049        return cls(
8050            meta=d.get('meta'),
8051            node=d.get('node'),
8052            rate_limit=d.get('rate_limit'),
8053            token=d.get('token'),
8054        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8006    def __init__(
8007        self,
8008        meta=None,
8009        node=None,
8010        rate_limit=None,
8011        token=None,
8012    ):
8013        self.meta = meta if meta is not None else None
8014        '''
8015         Reserved for future use.
8016        '''
8017        self.node = node if node is not None else None
8018        '''
8019         The created Node.
8020        '''
8021        self.rate_limit = rate_limit if rate_limit is not None else None
8022        '''
8023         Rate limit information.
8024        '''
8025        self.token = token if token is not None else ''
8026        '''
8027         The auth token generated for the Node. The Node will use this token to
8028         authenticate with the strongDM API.
8029        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8039    def to_dict(self):
8040        return {
8041            'meta': self.meta,
8042            'node': self.node,
8043            'rate_limit': self.rate_limit,
8044            'token': self.token,
8045        }
@classmethod
def from_dict(cls, d)
8047    @classmethod
8048    def from_dict(cls, d):
8049        return cls(
8050            meta=d.get('meta'),
8051            node=d.get('node'),
8052            rate_limit=d.get('rate_limit'),
8053            token=d.get('token'),
8054        )
class NodeDeleteResponse:
8057class NodeDeleteResponse:
8058    '''
8059         NodeDeleteResponse returns information about a Node that was deleted.
8060    '''
8061    __slots__ = [
8062        'meta',
8063        'rate_limit',
8064    ]
8065
8066    def __init__(
8067        self,
8068        meta=None,
8069        rate_limit=None,
8070    ):
8071        self.meta = meta if meta is not None else None
8072        '''
8073         Reserved for future use.
8074        '''
8075        self.rate_limit = rate_limit if rate_limit is not None else None
8076        '''
8077         Rate limit information.
8078        '''
8079
8080    def __repr__(self):
8081        return '<sdm.NodeDeleteResponse ' + \
8082            'meta: ' + repr(self.meta) + ' ' +\
8083            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8084            '>'
8085
8086    def to_dict(self):
8087        return {
8088            'meta': self.meta,
8089            'rate_limit': self.rate_limit,
8090        }
8091
8092    @classmethod
8093    def from_dict(cls, d):
8094        return cls(
8095            meta=d.get('meta'),
8096            rate_limit=d.get('rate_limit'),
8097        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8066    def __init__(
8067        self,
8068        meta=None,
8069        rate_limit=None,
8070    ):
8071        self.meta = meta if meta is not None else None
8072        '''
8073         Reserved for future use.
8074        '''
8075        self.rate_limit = rate_limit if rate_limit is not None else None
8076        '''
8077         Rate limit information.
8078        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8086    def to_dict(self):
8087        return {
8088            'meta': self.meta,
8089            'rate_limit': self.rate_limit,
8090        }
@classmethod
def from_dict(cls, d)
8092    @classmethod
8093    def from_dict(cls, d):
8094        return cls(
8095            meta=d.get('meta'),
8096            rate_limit=d.get('rate_limit'),
8097        )
class NodeGetResponse:
8100class NodeGetResponse:
8101    '''
8102         NodeGetResponse returns a requested Node.
8103    '''
8104    __slots__ = [
8105        'meta',
8106        'node',
8107        'rate_limit',
8108    ]
8109
8110    def __init__(
8111        self,
8112        meta=None,
8113        node=None,
8114        rate_limit=None,
8115    ):
8116        self.meta = meta if meta is not None else None
8117        '''
8118         Reserved for future use.
8119        '''
8120        self.node = node if node is not None else None
8121        '''
8122         The requested Node.
8123        '''
8124        self.rate_limit = rate_limit if rate_limit is not None else None
8125        '''
8126         Rate limit information.
8127        '''
8128
8129    def __repr__(self):
8130        return '<sdm.NodeGetResponse ' + \
8131            'meta: ' + repr(self.meta) + ' ' +\
8132            'node: ' + repr(self.node) + ' ' +\
8133            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8134            '>'
8135
8136    def to_dict(self):
8137        return {
8138            'meta': self.meta,
8139            'node': self.node,
8140            'rate_limit': self.rate_limit,
8141        }
8142
8143    @classmethod
8144    def from_dict(cls, d):
8145        return cls(
8146            meta=d.get('meta'),
8147            node=d.get('node'),
8148            rate_limit=d.get('rate_limit'),
8149        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8110    def __init__(
8111        self,
8112        meta=None,
8113        node=None,
8114        rate_limit=None,
8115    ):
8116        self.meta = meta if meta is not None else None
8117        '''
8118         Reserved for future use.
8119        '''
8120        self.node = node if node is not None else None
8121        '''
8122         The requested Node.
8123        '''
8124        self.rate_limit = rate_limit if rate_limit is not None else None
8125        '''
8126         Rate limit information.
8127        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8136    def to_dict(self):
8137        return {
8138            'meta': self.meta,
8139            'node': self.node,
8140            'rate_limit': self.rate_limit,
8141        }
@classmethod
def from_dict(cls, d)
8143    @classmethod
8144    def from_dict(cls, d):
8145        return cls(
8146            meta=d.get('meta'),
8147            node=d.get('node'),
8148            rate_limit=d.get('rate_limit'),
8149        )
class NodeUpdateResponse:
8152class NodeUpdateResponse:
8153    '''
8154         NodeUpdateResponse returns the fields of a Node after it has been updated by
8155     a NodeUpdateRequest.
8156    '''
8157    __slots__ = [
8158        'meta',
8159        'node',
8160        'rate_limit',
8161    ]
8162
8163    def __init__(
8164        self,
8165        meta=None,
8166        node=None,
8167        rate_limit=None,
8168    ):
8169        self.meta = meta if meta is not None else None
8170        '''
8171         Reserved for future use.
8172        '''
8173        self.node = node if node is not None else None
8174        '''
8175         The updated Node.
8176        '''
8177        self.rate_limit = rate_limit if rate_limit is not None else None
8178        '''
8179         Rate limit information.
8180        '''
8181
8182    def __repr__(self):
8183        return '<sdm.NodeUpdateResponse ' + \
8184            'meta: ' + repr(self.meta) + ' ' +\
8185            'node: ' + repr(self.node) + ' ' +\
8186            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8187            '>'
8188
8189    def to_dict(self):
8190        return {
8191            'meta': self.meta,
8192            'node': self.node,
8193            'rate_limit': self.rate_limit,
8194        }
8195
8196    @classmethod
8197    def from_dict(cls, d):
8198        return cls(
8199            meta=d.get('meta'),
8200            node=d.get('node'),
8201            rate_limit=d.get('rate_limit'),
8202        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8163    def __init__(
8164        self,
8165        meta=None,
8166        node=None,
8167        rate_limit=None,
8168    ):
8169        self.meta = meta if meta is not None else None
8170        '''
8171         Reserved for future use.
8172        '''
8173        self.node = node if node is not None else None
8174        '''
8175         The updated Node.
8176        '''
8177        self.rate_limit = rate_limit if rate_limit is not None else None
8178        '''
8179         Rate limit information.
8180        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8189    def to_dict(self):
8190        return {
8191            'meta': self.meta,
8192            'node': self.node,
8193            'rate_limit': self.rate_limit,
8194        }
@classmethod
def from_dict(cls, d)
8196    @classmethod
8197    def from_dict(cls, d):
8198        return cls(
8199            meta=d.get('meta'),
8200            node=d.get('node'),
8201            rate_limit=d.get('rate_limit'),
8202        )
class Oracle:
8205class Oracle:
8206    '''
8207    Oracle is currently unstable, and its API may change, or it may be removed,
8208    without a major version bump.
8209    '''
8210    __slots__ = [
8211        'bind_interface',
8212        'database',
8213        'egress_filter',
8214        'healthy',
8215        'hostname',
8216        'id',
8217        'name',
8218        'password',
8219        'port',
8220        'port_override',
8221        'secret_store_id',
8222        'tags',
8223        'tls_required',
8224        'username',
8225    ]
8226
8227    def __init__(
8228        self,
8229        bind_interface=None,
8230        database=None,
8231        egress_filter=None,
8232        healthy=None,
8233        hostname=None,
8234        id=None,
8235        name=None,
8236        password=None,
8237        port=None,
8238        port_override=None,
8239        secret_store_id=None,
8240        tags=None,
8241        tls_required=None,
8242        username=None,
8243    ):
8244        self.bind_interface = bind_interface if bind_interface is not None else ''
8245        '''
8246         Bind interface
8247        '''
8248        self.database = database if database is not None else ''
8249        self.egress_filter = egress_filter if egress_filter is not None else ''
8250        '''
8251         A filter applied to the routing logic to pin datasource to nodes.
8252        '''
8253        self.healthy = healthy if healthy is not None else False
8254        '''
8255         True if the datasource is reachable and the credentials are valid.
8256        '''
8257        self.hostname = hostname if hostname is not None else ''
8258        self.id = id if id is not None else ''
8259        '''
8260         Unique identifier of the Resource.
8261        '''
8262        self.name = name if name is not None else ''
8263        '''
8264         Unique human-readable name of the Resource.
8265        '''
8266        self.password = password if password is not None else ''
8267        self.port = port if port is not None else 0
8268        self.port_override = port_override if port_override is not None else 0
8269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8270        '''
8271         ID of the secret store containing credentials for this resource, if any.
8272        '''
8273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8274        '''
8275         Tags is a map of key, value pairs.
8276        '''
8277        self.tls_required = tls_required if tls_required is not None else False
8278        self.username = username if username is not None else ''
8279
8280    def __repr__(self):
8281        return '<sdm.Oracle ' + \
8282            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8283            'database: ' + repr(self.database) + ' ' +\
8284            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8285            'healthy: ' + repr(self.healthy) + ' ' +\
8286            'hostname: ' + repr(self.hostname) + ' ' +\
8287            'id: ' + repr(self.id) + ' ' +\
8288            'name: ' + repr(self.name) + ' ' +\
8289            'password: ' + repr(self.password) + ' ' +\
8290            'port: ' + repr(self.port) + ' ' +\
8291            'port_override: ' + repr(self.port_override) + ' ' +\
8292            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8293            'tags: ' + repr(self.tags) + ' ' +\
8294            'tls_required: ' + repr(self.tls_required) + ' ' +\
8295            'username: ' + repr(self.username) + ' ' +\
8296            '>'
8297
8298    def to_dict(self):
8299        return {
8300            'bind_interface': self.bind_interface,
8301            'database': self.database,
8302            'egress_filter': self.egress_filter,
8303            'healthy': self.healthy,
8304            'hostname': self.hostname,
8305            'id': self.id,
8306            'name': self.name,
8307            'password': self.password,
8308            'port': self.port,
8309            'port_override': self.port_override,
8310            'secret_store_id': self.secret_store_id,
8311            'tags': self.tags,
8312            'tls_required': self.tls_required,
8313            'username': self.username,
8314        }
8315
8316    @classmethod
8317    def from_dict(cls, d):
8318        return cls(
8319            bind_interface=d.get('bind_interface'),
8320            database=d.get('database'),
8321            egress_filter=d.get('egress_filter'),
8322            healthy=d.get('healthy'),
8323            hostname=d.get('hostname'),
8324            id=d.get('id'),
8325            name=d.get('name'),
8326            password=d.get('password'),
8327            port=d.get('port'),
8328            port_override=d.get('port_override'),
8329            secret_store_id=d.get('secret_store_id'),
8330            tags=d.get('tags'),
8331            tls_required=d.get('tls_required'),
8332            username=d.get('username'),
8333        )

Oracle is currently unstable, and its API may change, or it may be removed, without a major version bump.

Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8227    def __init__(
8228        self,
8229        bind_interface=None,
8230        database=None,
8231        egress_filter=None,
8232        healthy=None,
8233        hostname=None,
8234        id=None,
8235        name=None,
8236        password=None,
8237        port=None,
8238        port_override=None,
8239        secret_store_id=None,
8240        tags=None,
8241        tls_required=None,
8242        username=None,
8243    ):
8244        self.bind_interface = bind_interface if bind_interface is not None else ''
8245        '''
8246         Bind interface
8247        '''
8248        self.database = database if database is not None else ''
8249        self.egress_filter = egress_filter if egress_filter is not None else ''
8250        '''
8251         A filter applied to the routing logic to pin datasource to nodes.
8252        '''
8253        self.healthy = healthy if healthy is not None else False
8254        '''
8255         True if the datasource is reachable and the credentials are valid.
8256        '''
8257        self.hostname = hostname if hostname is not None else ''
8258        self.id = id if id is not None else ''
8259        '''
8260         Unique identifier of the Resource.
8261        '''
8262        self.name = name if name is not None else ''
8263        '''
8264         Unique human-readable name of the Resource.
8265        '''
8266        self.password = password if password is not None else ''
8267        self.port = port if port is not None else 0
8268        self.port_override = port_override if port_override is not None else 0
8269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8270        '''
8271         ID of the secret store containing credentials for this resource, if any.
8272        '''
8273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8274        '''
8275         Tags is a map of key, value pairs.
8276        '''
8277        self.tls_required = tls_required if tls_required is not None else False
8278        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8298    def to_dict(self):
8299        return {
8300            'bind_interface': self.bind_interface,
8301            'database': self.database,
8302            'egress_filter': self.egress_filter,
8303            'healthy': self.healthy,
8304            'hostname': self.hostname,
8305            'id': self.id,
8306            'name': self.name,
8307            'password': self.password,
8308            'port': self.port,
8309            'port_override': self.port_override,
8310            'secret_store_id': self.secret_store_id,
8311            'tags': self.tags,
8312            'tls_required': self.tls_required,
8313            'username': self.username,
8314        }
@classmethod
def from_dict(cls, d)
8316    @classmethod
8317    def from_dict(cls, d):
8318        return cls(
8319            bind_interface=d.get('bind_interface'),
8320            database=d.get('database'),
8321            egress_filter=d.get('egress_filter'),
8322            healthy=d.get('healthy'),
8323            hostname=d.get('hostname'),
8324            id=d.get('id'),
8325            name=d.get('name'),
8326            password=d.get('password'),
8327            port=d.get('port'),
8328            port_override=d.get('port_override'),
8329            secret_store_id=d.get('secret_store_id'),
8330            tags=d.get('tags'),
8331            tls_required=d.get('tls_required'),
8332            username=d.get('username'),
8333        )
class Postgres:
8336class Postgres:
8337    __slots__ = [
8338        'bind_interface',
8339        'database',
8340        'egress_filter',
8341        'healthy',
8342        'hostname',
8343        'id',
8344        'name',
8345        'override_database',
8346        'password',
8347        'port',
8348        'port_override',
8349        'secret_store_id',
8350        'tags',
8351        'username',
8352    ]
8353
8354    def __init__(
8355        self,
8356        bind_interface=None,
8357        database=None,
8358        egress_filter=None,
8359        healthy=None,
8360        hostname=None,
8361        id=None,
8362        name=None,
8363        override_database=None,
8364        password=None,
8365        port=None,
8366        port_override=None,
8367        secret_store_id=None,
8368        tags=None,
8369        username=None,
8370    ):
8371        self.bind_interface = bind_interface if bind_interface is not None else ''
8372        '''
8373         Bind interface
8374        '''
8375        self.database = database if database is not None else ''
8376        self.egress_filter = egress_filter if egress_filter is not None else ''
8377        '''
8378         A filter applied to the routing logic to pin datasource to nodes.
8379        '''
8380        self.healthy = healthy if healthy is not None else False
8381        '''
8382         True if the datasource is reachable and the credentials are valid.
8383        '''
8384        self.hostname = hostname if hostname is not None else ''
8385        self.id = id if id is not None else ''
8386        '''
8387         Unique identifier of the Resource.
8388        '''
8389        self.name = name if name is not None else ''
8390        '''
8391         Unique human-readable name of the Resource.
8392        '''
8393        self.override_database = override_database if override_database is not None else False
8394        self.password = password if password is not None else ''
8395        self.port = port if port is not None else 0
8396        self.port_override = port_override if port_override is not None else 0
8397        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8398        '''
8399         ID of the secret store containing credentials for this resource, if any.
8400        '''
8401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8402        '''
8403         Tags is a map of key, value pairs.
8404        '''
8405        self.username = username if username is not None else ''
8406
8407    def __repr__(self):
8408        return '<sdm.Postgres ' + \
8409            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8410            'database: ' + repr(self.database) + ' ' +\
8411            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8412            'healthy: ' + repr(self.healthy) + ' ' +\
8413            'hostname: ' + repr(self.hostname) + ' ' +\
8414            'id: ' + repr(self.id) + ' ' +\
8415            'name: ' + repr(self.name) + ' ' +\
8416            'override_database: ' + repr(self.override_database) + ' ' +\
8417            'password: ' + repr(self.password) + ' ' +\
8418            'port: ' + repr(self.port) + ' ' +\
8419            'port_override: ' + repr(self.port_override) + ' ' +\
8420            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8421            'tags: ' + repr(self.tags) + ' ' +\
8422            'username: ' + repr(self.username) + ' ' +\
8423            '>'
8424
8425    def to_dict(self):
8426        return {
8427            'bind_interface': self.bind_interface,
8428            'database': self.database,
8429            'egress_filter': self.egress_filter,
8430            'healthy': self.healthy,
8431            'hostname': self.hostname,
8432            'id': self.id,
8433            'name': self.name,
8434            'override_database': self.override_database,
8435            'password': self.password,
8436            'port': self.port,
8437            'port_override': self.port_override,
8438            'secret_store_id': self.secret_store_id,
8439            'tags': self.tags,
8440            'username': self.username,
8441        }
8442
8443    @classmethod
8444    def from_dict(cls, d):
8445        return cls(
8446            bind_interface=d.get('bind_interface'),
8447            database=d.get('database'),
8448            egress_filter=d.get('egress_filter'),
8449            healthy=d.get('healthy'),
8450            hostname=d.get('hostname'),
8451            id=d.get('id'),
8452            name=d.get('name'),
8453            override_database=d.get('override_database'),
8454            password=d.get('password'),
8455            port=d.get('port'),
8456            port_override=d.get('port_override'),
8457            secret_store_id=d.get('secret_store_id'),
8458            tags=d.get('tags'),
8459            username=d.get('username'),
8460        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8354    def __init__(
8355        self,
8356        bind_interface=None,
8357        database=None,
8358        egress_filter=None,
8359        healthy=None,
8360        hostname=None,
8361        id=None,
8362        name=None,
8363        override_database=None,
8364        password=None,
8365        port=None,
8366        port_override=None,
8367        secret_store_id=None,
8368        tags=None,
8369        username=None,
8370    ):
8371        self.bind_interface = bind_interface if bind_interface is not None else ''
8372        '''
8373         Bind interface
8374        '''
8375        self.database = database if database is not None else ''
8376        self.egress_filter = egress_filter if egress_filter is not None else ''
8377        '''
8378         A filter applied to the routing logic to pin datasource to nodes.
8379        '''
8380        self.healthy = healthy if healthy is not None else False
8381        '''
8382         True if the datasource is reachable and the credentials are valid.
8383        '''
8384        self.hostname = hostname if hostname is not None else ''
8385        self.id = id if id is not None else ''
8386        '''
8387         Unique identifier of the Resource.
8388        '''
8389        self.name = name if name is not None else ''
8390        '''
8391         Unique human-readable name of the Resource.
8392        '''
8393        self.override_database = override_database if override_database is not None else False
8394        self.password = password if password is not None else ''
8395        self.port = port if port is not None else 0
8396        self.port_override = port_override if port_override is not None else 0
8397        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8398        '''
8399         ID of the secret store containing credentials for this resource, if any.
8400        '''
8401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8402        '''
8403         Tags is a map of key, value pairs.
8404        '''
8405        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8425    def to_dict(self):
8426        return {
8427            'bind_interface': self.bind_interface,
8428            'database': self.database,
8429            'egress_filter': self.egress_filter,
8430            'healthy': self.healthy,
8431            'hostname': self.hostname,
8432            'id': self.id,
8433            'name': self.name,
8434            'override_database': self.override_database,
8435            'password': self.password,
8436            'port': self.port,
8437            'port_override': self.port_override,
8438            'secret_store_id': self.secret_store_id,
8439            'tags': self.tags,
8440            'username': self.username,
8441        }
@classmethod
def from_dict(cls, d)
8443    @classmethod
8444    def from_dict(cls, d):
8445        return cls(
8446            bind_interface=d.get('bind_interface'),
8447            database=d.get('database'),
8448            egress_filter=d.get('egress_filter'),
8449            healthy=d.get('healthy'),
8450            hostname=d.get('hostname'),
8451            id=d.get('id'),
8452            name=d.get('name'),
8453            override_database=d.get('override_database'),
8454            password=d.get('password'),
8455            port=d.get('port'),
8456            port_override=d.get('port_override'),
8457            secret_store_id=d.get('secret_store_id'),
8458            tags=d.get('tags'),
8459            username=d.get('username'),
8460        )
class Presto:
8463class Presto:
8464    __slots__ = [
8465        'bind_interface',
8466        'database',
8467        'egress_filter',
8468        'healthy',
8469        'hostname',
8470        'id',
8471        'name',
8472        'password',
8473        'port',
8474        'port_override',
8475        'secret_store_id',
8476        'tags',
8477        'tls_required',
8478        'username',
8479    ]
8480
8481    def __init__(
8482        self,
8483        bind_interface=None,
8484        database=None,
8485        egress_filter=None,
8486        healthy=None,
8487        hostname=None,
8488        id=None,
8489        name=None,
8490        password=None,
8491        port=None,
8492        port_override=None,
8493        secret_store_id=None,
8494        tags=None,
8495        tls_required=None,
8496        username=None,
8497    ):
8498        self.bind_interface = bind_interface if bind_interface is not None else ''
8499        '''
8500         Bind interface
8501        '''
8502        self.database = database if database is not None else ''
8503        self.egress_filter = egress_filter if egress_filter is not None else ''
8504        '''
8505         A filter applied to the routing logic to pin datasource to nodes.
8506        '''
8507        self.healthy = healthy if healthy is not None else False
8508        '''
8509         True if the datasource is reachable and the credentials are valid.
8510        '''
8511        self.hostname = hostname if hostname is not None else ''
8512        self.id = id if id is not None else ''
8513        '''
8514         Unique identifier of the Resource.
8515        '''
8516        self.name = name if name is not None else ''
8517        '''
8518         Unique human-readable name of the Resource.
8519        '''
8520        self.password = password if password is not None else ''
8521        self.port = port if port is not None else 0
8522        self.port_override = port_override if port_override is not None else 0
8523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8524        '''
8525         ID of the secret store containing credentials for this resource, if any.
8526        '''
8527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8528        '''
8529         Tags is a map of key, value pairs.
8530        '''
8531        self.tls_required = tls_required if tls_required is not None else False
8532        self.username = username if username is not None else ''
8533
8534    def __repr__(self):
8535        return '<sdm.Presto ' + \
8536            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8537            'database: ' + repr(self.database) + ' ' +\
8538            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8539            'healthy: ' + repr(self.healthy) + ' ' +\
8540            'hostname: ' + repr(self.hostname) + ' ' +\
8541            'id: ' + repr(self.id) + ' ' +\
8542            'name: ' + repr(self.name) + ' ' +\
8543            'password: ' + repr(self.password) + ' ' +\
8544            'port: ' + repr(self.port) + ' ' +\
8545            'port_override: ' + repr(self.port_override) + ' ' +\
8546            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8547            'tags: ' + repr(self.tags) + ' ' +\
8548            'tls_required: ' + repr(self.tls_required) + ' ' +\
8549            'username: ' + repr(self.username) + ' ' +\
8550            '>'
8551
8552    def to_dict(self):
8553        return {
8554            'bind_interface': self.bind_interface,
8555            'database': self.database,
8556            'egress_filter': self.egress_filter,
8557            'healthy': self.healthy,
8558            'hostname': self.hostname,
8559            'id': self.id,
8560            'name': self.name,
8561            'password': self.password,
8562            'port': self.port,
8563            'port_override': self.port_override,
8564            'secret_store_id': self.secret_store_id,
8565            'tags': self.tags,
8566            'tls_required': self.tls_required,
8567            'username': self.username,
8568        }
8569
8570    @classmethod
8571    def from_dict(cls, d):
8572        return cls(
8573            bind_interface=d.get('bind_interface'),
8574            database=d.get('database'),
8575            egress_filter=d.get('egress_filter'),
8576            healthy=d.get('healthy'),
8577            hostname=d.get('hostname'),
8578            id=d.get('id'),
8579            name=d.get('name'),
8580            password=d.get('password'),
8581            port=d.get('port'),
8582            port_override=d.get('port_override'),
8583            secret_store_id=d.get('secret_store_id'),
8584            tags=d.get('tags'),
8585            tls_required=d.get('tls_required'),
8586            username=d.get('username'),
8587        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8481    def __init__(
8482        self,
8483        bind_interface=None,
8484        database=None,
8485        egress_filter=None,
8486        healthy=None,
8487        hostname=None,
8488        id=None,
8489        name=None,
8490        password=None,
8491        port=None,
8492        port_override=None,
8493        secret_store_id=None,
8494        tags=None,
8495        tls_required=None,
8496        username=None,
8497    ):
8498        self.bind_interface = bind_interface if bind_interface is not None else ''
8499        '''
8500         Bind interface
8501        '''
8502        self.database = database if database is not None else ''
8503        self.egress_filter = egress_filter if egress_filter is not None else ''
8504        '''
8505         A filter applied to the routing logic to pin datasource to nodes.
8506        '''
8507        self.healthy = healthy if healthy is not None else False
8508        '''
8509         True if the datasource is reachable and the credentials are valid.
8510        '''
8511        self.hostname = hostname if hostname is not None else ''
8512        self.id = id if id is not None else ''
8513        '''
8514         Unique identifier of the Resource.
8515        '''
8516        self.name = name if name is not None else ''
8517        '''
8518         Unique human-readable name of the Resource.
8519        '''
8520        self.password = password if password is not None else ''
8521        self.port = port if port is not None else 0
8522        self.port_override = port_override if port_override is not None else 0
8523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8524        '''
8525         ID of the secret store containing credentials for this resource, if any.
8526        '''
8527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8528        '''
8529         Tags is a map of key, value pairs.
8530        '''
8531        self.tls_required = tls_required if tls_required is not None else False
8532        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8552    def to_dict(self):
8553        return {
8554            'bind_interface': self.bind_interface,
8555            'database': self.database,
8556            'egress_filter': self.egress_filter,
8557            'healthy': self.healthy,
8558            'hostname': self.hostname,
8559            'id': self.id,
8560            'name': self.name,
8561            'password': self.password,
8562            'port': self.port,
8563            'port_override': self.port_override,
8564            'secret_store_id': self.secret_store_id,
8565            'tags': self.tags,
8566            'tls_required': self.tls_required,
8567            'username': self.username,
8568        }
@classmethod
def from_dict(cls, d)
8570    @classmethod
8571    def from_dict(cls, d):
8572        return cls(
8573            bind_interface=d.get('bind_interface'),
8574            database=d.get('database'),
8575            egress_filter=d.get('egress_filter'),
8576            healthy=d.get('healthy'),
8577            hostname=d.get('hostname'),
8578            id=d.get('id'),
8579            name=d.get('name'),
8580            password=d.get('password'),
8581            port=d.get('port'),
8582            port_override=d.get('port_override'),
8583            secret_store_id=d.get('secret_store_id'),
8584            tags=d.get('tags'),
8585            tls_required=d.get('tls_required'),
8586            username=d.get('username'),
8587        )
class RDP:
8590class RDP:
8591    __slots__ = [
8592        'bind_interface',
8593        'downgrade_nla_connections',
8594        'egress_filter',
8595        'healthy',
8596        'hostname',
8597        'id',
8598        'name',
8599        'password',
8600        'port',
8601        'port_override',
8602        'secret_store_id',
8603        'tags',
8604        'username',
8605    ]
8606
8607    def __init__(
8608        self,
8609        bind_interface=None,
8610        downgrade_nla_connections=None,
8611        egress_filter=None,
8612        healthy=None,
8613        hostname=None,
8614        id=None,
8615        name=None,
8616        password=None,
8617        port=None,
8618        port_override=None,
8619        secret_store_id=None,
8620        tags=None,
8621        username=None,
8622    ):
8623        self.bind_interface = bind_interface if bind_interface is not None else ''
8624        '''
8625         Bind interface
8626        '''
8627        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8628        self.egress_filter = egress_filter if egress_filter is not None else ''
8629        '''
8630         A filter applied to the routing logic to pin datasource to nodes.
8631        '''
8632        self.healthy = healthy if healthy is not None else False
8633        '''
8634         True if the datasource is reachable and the credentials are valid.
8635        '''
8636        self.hostname = hostname if hostname is not None else ''
8637        self.id = id if id is not None else ''
8638        '''
8639         Unique identifier of the Resource.
8640        '''
8641        self.name = name if name is not None else ''
8642        '''
8643         Unique human-readable name of the Resource.
8644        '''
8645        self.password = password if password is not None else ''
8646        self.port = port if port is not None else 0
8647        self.port_override = port_override if port_override is not None else 0
8648        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8649        '''
8650         ID of the secret store containing credentials for this resource, if any.
8651        '''
8652        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8653        '''
8654         Tags is a map of key, value pairs.
8655        '''
8656        self.username = username if username is not None else ''
8657
8658    def __repr__(self):
8659        return '<sdm.RDP ' + \
8660            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8661            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
8662            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8663            'healthy: ' + repr(self.healthy) + ' ' +\
8664            'hostname: ' + repr(self.hostname) + ' ' +\
8665            'id: ' + repr(self.id) + ' ' +\
8666            'name: ' + repr(self.name) + ' ' +\
8667            'password: ' + repr(self.password) + ' ' +\
8668            'port: ' + repr(self.port) + ' ' +\
8669            'port_override: ' + repr(self.port_override) + ' ' +\
8670            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8671            'tags: ' + repr(self.tags) + ' ' +\
8672            'username: ' + repr(self.username) + ' ' +\
8673            '>'
8674
8675    def to_dict(self):
8676        return {
8677            'bind_interface': self.bind_interface,
8678            'downgrade_nla_connections': self.downgrade_nla_connections,
8679            'egress_filter': self.egress_filter,
8680            'healthy': self.healthy,
8681            'hostname': self.hostname,
8682            'id': self.id,
8683            'name': self.name,
8684            'password': self.password,
8685            'port': self.port,
8686            'port_override': self.port_override,
8687            'secret_store_id': self.secret_store_id,
8688            'tags': self.tags,
8689            'username': self.username,
8690        }
8691
8692    @classmethod
8693    def from_dict(cls, d):
8694        return cls(
8695            bind_interface=d.get('bind_interface'),
8696            downgrade_nla_connections=d.get('downgrade_nla_connections'),
8697            egress_filter=d.get('egress_filter'),
8698            healthy=d.get('healthy'),
8699            hostname=d.get('hostname'),
8700            id=d.get('id'),
8701            name=d.get('name'),
8702            password=d.get('password'),
8703            port=d.get('port'),
8704            port_override=d.get('port_override'),
8705            secret_store_id=d.get('secret_store_id'),
8706            tags=d.get('tags'),
8707            username=d.get('username'),
8708        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8607    def __init__(
8608        self,
8609        bind_interface=None,
8610        downgrade_nla_connections=None,
8611        egress_filter=None,
8612        healthy=None,
8613        hostname=None,
8614        id=None,
8615        name=None,
8616        password=None,
8617        port=None,
8618        port_override=None,
8619        secret_store_id=None,
8620        tags=None,
8621        username=None,
8622    ):
8623        self.bind_interface = bind_interface if bind_interface is not None else ''
8624        '''
8625         Bind interface
8626        '''
8627        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8628        self.egress_filter = egress_filter if egress_filter is not None else ''
8629        '''
8630         A filter applied to the routing logic to pin datasource to nodes.
8631        '''
8632        self.healthy = healthy if healthy is not None else False
8633        '''
8634         True if the datasource is reachable and the credentials are valid.
8635        '''
8636        self.hostname = hostname if hostname is not None else ''
8637        self.id = id if id is not None else ''
8638        '''
8639         Unique identifier of the Resource.
8640        '''
8641        self.name = name if name is not None else ''
8642        '''
8643         Unique human-readable name of the Resource.
8644        '''
8645        self.password = password if password is not None else ''
8646        self.port = port if port is not None else 0
8647        self.port_override = port_override if port_override is not None else 0
8648        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8649        '''
8650         ID of the secret store containing credentials for this resource, if any.
8651        '''
8652        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8653        '''
8654         Tags is a map of key, value pairs.
8655        '''
8656        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8675    def to_dict(self):
8676        return {
8677            'bind_interface': self.bind_interface,
8678            'downgrade_nla_connections': self.downgrade_nla_connections,
8679            'egress_filter': self.egress_filter,
8680            'healthy': self.healthy,
8681            'hostname': self.hostname,
8682            'id': self.id,
8683            'name': self.name,
8684            'password': self.password,
8685            'port': self.port,
8686            'port_override': self.port_override,
8687            'secret_store_id': self.secret_store_id,
8688            'tags': self.tags,
8689            'username': self.username,
8690        }
@classmethod
def from_dict(cls, d)
8692    @classmethod
8693    def from_dict(cls, d):
8694        return cls(
8695            bind_interface=d.get('bind_interface'),
8696            downgrade_nla_connections=d.get('downgrade_nla_connections'),
8697            egress_filter=d.get('egress_filter'),
8698            healthy=d.get('healthy'),
8699            hostname=d.get('hostname'),
8700            id=d.get('id'),
8701            name=d.get('name'),
8702            password=d.get('password'),
8703            port=d.get('port'),
8704            port_override=d.get('port_override'),
8705            secret_store_id=d.get('secret_store_id'),
8706            tags=d.get('tags'),
8707            username=d.get('username'),
8708        )
class RabbitMQAMQP091:
8711class RabbitMQAMQP091:
8712    __slots__ = [
8713        'bind_interface',
8714        'egress_filter',
8715        'healthy',
8716        'hostname',
8717        'id',
8718        'name',
8719        'password',
8720        'port',
8721        'port_override',
8722        'secret_store_id',
8723        'tags',
8724        'tls_required',
8725        'username',
8726    ]
8727
8728    def __init__(
8729        self,
8730        bind_interface=None,
8731        egress_filter=None,
8732        healthy=None,
8733        hostname=None,
8734        id=None,
8735        name=None,
8736        password=None,
8737        port=None,
8738        port_override=None,
8739        secret_store_id=None,
8740        tags=None,
8741        tls_required=None,
8742        username=None,
8743    ):
8744        self.bind_interface = bind_interface if bind_interface is not None else ''
8745        '''
8746         Bind interface
8747        '''
8748        self.egress_filter = egress_filter if egress_filter is not None else ''
8749        '''
8750         A filter applied to the routing logic to pin datasource to nodes.
8751        '''
8752        self.healthy = healthy if healthy is not None else False
8753        '''
8754         True if the datasource is reachable and the credentials are valid.
8755        '''
8756        self.hostname = hostname if hostname is not None else ''
8757        self.id = id if id is not None else ''
8758        '''
8759         Unique identifier of the Resource.
8760        '''
8761        self.name = name if name is not None else ''
8762        '''
8763         Unique human-readable name of the Resource.
8764        '''
8765        self.password = password if password is not None else ''
8766        self.port = port if port is not None else 0
8767        self.port_override = port_override if port_override is not None else 0
8768        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8769        '''
8770         ID of the secret store containing credentials for this resource, if any.
8771        '''
8772        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8773        '''
8774         Tags is a map of key, value pairs.
8775        '''
8776        self.tls_required = tls_required if tls_required is not None else False
8777        self.username = username if username is not None else ''
8778
8779    def __repr__(self):
8780        return '<sdm.RabbitMQAMQP091 ' + \
8781            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8782            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8783            'healthy: ' + repr(self.healthy) + ' ' +\
8784            'hostname: ' + repr(self.hostname) + ' ' +\
8785            'id: ' + repr(self.id) + ' ' +\
8786            'name: ' + repr(self.name) + ' ' +\
8787            'password: ' + repr(self.password) + ' ' +\
8788            'port: ' + repr(self.port) + ' ' +\
8789            'port_override: ' + repr(self.port_override) + ' ' +\
8790            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8791            'tags: ' + repr(self.tags) + ' ' +\
8792            'tls_required: ' + repr(self.tls_required) + ' ' +\
8793            'username: ' + repr(self.username) + ' ' +\
8794            '>'
8795
8796    def to_dict(self):
8797        return {
8798            'bind_interface': self.bind_interface,
8799            'egress_filter': self.egress_filter,
8800            'healthy': self.healthy,
8801            'hostname': self.hostname,
8802            'id': self.id,
8803            'name': self.name,
8804            'password': self.password,
8805            'port': self.port,
8806            'port_override': self.port_override,
8807            'secret_store_id': self.secret_store_id,
8808            'tags': self.tags,
8809            'tls_required': self.tls_required,
8810            'username': self.username,
8811        }
8812
8813    @classmethod
8814    def from_dict(cls, d):
8815        return cls(
8816            bind_interface=d.get('bind_interface'),
8817            egress_filter=d.get('egress_filter'),
8818            healthy=d.get('healthy'),
8819            hostname=d.get('hostname'),
8820            id=d.get('id'),
8821            name=d.get('name'),
8822            password=d.get('password'),
8823            port=d.get('port'),
8824            port_override=d.get('port_override'),
8825            secret_store_id=d.get('secret_store_id'),
8826            tags=d.get('tags'),
8827            tls_required=d.get('tls_required'),
8828            username=d.get('username'),
8829        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8728    def __init__(
8729        self,
8730        bind_interface=None,
8731        egress_filter=None,
8732        healthy=None,
8733        hostname=None,
8734        id=None,
8735        name=None,
8736        password=None,
8737        port=None,
8738        port_override=None,
8739        secret_store_id=None,
8740        tags=None,
8741        tls_required=None,
8742        username=None,
8743    ):
8744        self.bind_interface = bind_interface if bind_interface is not None else ''
8745        '''
8746         Bind interface
8747        '''
8748        self.egress_filter = egress_filter if egress_filter is not None else ''
8749        '''
8750         A filter applied to the routing logic to pin datasource to nodes.
8751        '''
8752        self.healthy = healthy if healthy is not None else False
8753        '''
8754         True if the datasource is reachable and the credentials are valid.
8755        '''
8756        self.hostname = hostname if hostname is not None else ''
8757        self.id = id if id is not None else ''
8758        '''
8759         Unique identifier of the Resource.
8760        '''
8761        self.name = name if name is not None else ''
8762        '''
8763         Unique human-readable name of the Resource.
8764        '''
8765        self.password = password if password is not None else ''
8766        self.port = port if port is not None else 0
8767        self.port_override = port_override if port_override is not None else 0
8768        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8769        '''
8770         ID of the secret store containing credentials for this resource, if any.
8771        '''
8772        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8773        '''
8774         Tags is a map of key, value pairs.
8775        '''
8776        self.tls_required = tls_required if tls_required is not None else False
8777        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8796    def to_dict(self):
8797        return {
8798            'bind_interface': self.bind_interface,
8799            'egress_filter': self.egress_filter,
8800            'healthy': self.healthy,
8801            'hostname': self.hostname,
8802            'id': self.id,
8803            'name': self.name,
8804            'password': self.password,
8805            'port': self.port,
8806            'port_override': self.port_override,
8807            'secret_store_id': self.secret_store_id,
8808            'tags': self.tags,
8809            'tls_required': self.tls_required,
8810            'username': self.username,
8811        }
@classmethod
def from_dict(cls, d)
8813    @classmethod
8814    def from_dict(cls, d):
8815        return cls(
8816            bind_interface=d.get('bind_interface'),
8817            egress_filter=d.get('egress_filter'),
8818            healthy=d.get('healthy'),
8819            hostname=d.get('hostname'),
8820            id=d.get('id'),
8821            name=d.get('name'),
8822            password=d.get('password'),
8823            port=d.get('port'),
8824            port_override=d.get('port_override'),
8825            secret_store_id=d.get('secret_store_id'),
8826            tags=d.get('tags'),
8827            tls_required=d.get('tls_required'),
8828            username=d.get('username'),
8829        )
class RateLimitMetadata:
8832class RateLimitMetadata:
8833    '''
8834         RateLimitMetadata contains information about remaining requests avaialable
8835     to the user over some timeframe.
8836    '''
8837    __slots__ = [
8838        'bucket',
8839        'limit',
8840        'remaining',
8841        'reset_at',
8842    ]
8843
8844    def __init__(
8845        self,
8846        bucket=None,
8847        limit=None,
8848        remaining=None,
8849        reset_at=None,
8850    ):
8851        self.bucket = bucket if bucket is not None else ''
8852        '''
8853         The bucket this user/token is associated with, which may be shared between
8854         multiple users/tokens.
8855        '''
8856        self.limit = limit if limit is not None else 0
8857        '''
8858         How many total requests the user/token is authorized to make before being
8859         rate limited.
8860        '''
8861        self.remaining = remaining if remaining is not None else 0
8862        '''
8863         How many remaining requests out of the limit are still avaialable.
8864        '''
8865        self.reset_at = reset_at if reset_at is not None else None
8866        '''
8867         The time when remaining will be reset to limit.
8868        '''
8869
8870    def __repr__(self):
8871        return '<sdm.RateLimitMetadata ' + \
8872            'bucket: ' + repr(self.bucket) + ' ' +\
8873            'limit: ' + repr(self.limit) + ' ' +\
8874            'remaining: ' + repr(self.remaining) + ' ' +\
8875            'reset_at: ' + repr(self.reset_at) + ' ' +\
8876            '>'
8877
8878    def to_dict(self):
8879        return {
8880            'bucket': self.bucket,
8881            'limit': self.limit,
8882            'remaining': self.remaining,
8883            'reset_at': self.reset_at,
8884        }
8885
8886    @classmethod
8887    def from_dict(cls, d):
8888        return cls(
8889            bucket=d.get('bucket'),
8890            limit=d.get('limit'),
8891            remaining=d.get('remaining'),
8892            reset_at=d.get('reset_at'),
8893        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
8844    def __init__(
8845        self,
8846        bucket=None,
8847        limit=None,
8848        remaining=None,
8849        reset_at=None,
8850    ):
8851        self.bucket = bucket if bucket is not None else ''
8852        '''
8853         The bucket this user/token is associated with, which may be shared between
8854         multiple users/tokens.
8855        '''
8856        self.limit = limit if limit is not None else 0
8857        '''
8858         How many total requests the user/token is authorized to make before being
8859         rate limited.
8860        '''
8861        self.remaining = remaining if remaining is not None else 0
8862        '''
8863         How many remaining requests out of the limit are still avaialable.
8864        '''
8865        self.reset_at = reset_at if reset_at is not None else None
8866        '''
8867         The time when remaining will be reset to limit.
8868        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
8878    def to_dict(self):
8879        return {
8880            'bucket': self.bucket,
8881            'limit': self.limit,
8882            'remaining': self.remaining,
8883            'reset_at': self.reset_at,
8884        }
@classmethod
def from_dict(cls, d)
8886    @classmethod
8887    def from_dict(cls, d):
8888        return cls(
8889            bucket=d.get('bucket'),
8890            limit=d.get('limit'),
8891            remaining=d.get('remaining'),
8892            reset_at=d.get('reset_at'),
8893        )
class RawTCP:
8896class RawTCP:
8897    __slots__ = [
8898        'bind_interface',
8899        'egress_filter',
8900        'healthy',
8901        'hostname',
8902        'id',
8903        'name',
8904        'port',
8905        'port_override',
8906        'secret_store_id',
8907        'tags',
8908    ]
8909
8910    def __init__(
8911        self,
8912        bind_interface=None,
8913        egress_filter=None,
8914        healthy=None,
8915        hostname=None,
8916        id=None,
8917        name=None,
8918        port=None,
8919        port_override=None,
8920        secret_store_id=None,
8921        tags=None,
8922    ):
8923        self.bind_interface = bind_interface if bind_interface is not None else ''
8924        '''
8925         Bind interface
8926        '''
8927        self.egress_filter = egress_filter if egress_filter is not None else ''
8928        '''
8929         A filter applied to the routing logic to pin datasource to nodes.
8930        '''
8931        self.healthy = healthy if healthy is not None else False
8932        '''
8933         True if the datasource is reachable and the credentials are valid.
8934        '''
8935        self.hostname = hostname if hostname is not None else ''
8936        self.id = id if id is not None else ''
8937        '''
8938         Unique identifier of the Resource.
8939        '''
8940        self.name = name if name is not None else ''
8941        '''
8942         Unique human-readable name of the Resource.
8943        '''
8944        self.port = port if port is not None else 0
8945        self.port_override = port_override if port_override is not None else 0
8946        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8947        '''
8948         ID of the secret store containing credentials for this resource, if any.
8949        '''
8950        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8951        '''
8952         Tags is a map of key, value pairs.
8953        '''
8954
8955    def __repr__(self):
8956        return '<sdm.RawTCP ' + \
8957            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8958            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8959            'healthy: ' + repr(self.healthy) + ' ' +\
8960            'hostname: ' + repr(self.hostname) + ' ' +\
8961            'id: ' + repr(self.id) + ' ' +\
8962            'name: ' + repr(self.name) + ' ' +\
8963            'port: ' + repr(self.port) + ' ' +\
8964            'port_override: ' + repr(self.port_override) + ' ' +\
8965            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8966            'tags: ' + repr(self.tags) + ' ' +\
8967            '>'
8968
8969    def to_dict(self):
8970        return {
8971            'bind_interface': self.bind_interface,
8972            'egress_filter': self.egress_filter,
8973            'healthy': self.healthy,
8974            'hostname': self.hostname,
8975            'id': self.id,
8976            'name': self.name,
8977            'port': self.port,
8978            'port_override': self.port_override,
8979            'secret_store_id': self.secret_store_id,
8980            'tags': self.tags,
8981        }
8982
8983    @classmethod
8984    def from_dict(cls, d):
8985        return cls(
8986            bind_interface=d.get('bind_interface'),
8987            egress_filter=d.get('egress_filter'),
8988            healthy=d.get('healthy'),
8989            hostname=d.get('hostname'),
8990            id=d.get('id'),
8991            name=d.get('name'),
8992            port=d.get('port'),
8993            port_override=d.get('port_override'),
8994            secret_store_id=d.get('secret_store_id'),
8995            tags=d.get('tags'),
8996        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8910    def __init__(
8911        self,
8912        bind_interface=None,
8913        egress_filter=None,
8914        healthy=None,
8915        hostname=None,
8916        id=None,
8917        name=None,
8918        port=None,
8919        port_override=None,
8920        secret_store_id=None,
8921        tags=None,
8922    ):
8923        self.bind_interface = bind_interface if bind_interface is not None else ''
8924        '''
8925         Bind interface
8926        '''
8927        self.egress_filter = egress_filter if egress_filter is not None else ''
8928        '''
8929         A filter applied to the routing logic to pin datasource to nodes.
8930        '''
8931        self.healthy = healthy if healthy is not None else False
8932        '''
8933         True if the datasource is reachable and the credentials are valid.
8934        '''
8935        self.hostname = hostname if hostname is not None else ''
8936        self.id = id if id is not None else ''
8937        '''
8938         Unique identifier of the Resource.
8939        '''
8940        self.name = name if name is not None else ''
8941        '''
8942         Unique human-readable name of the Resource.
8943        '''
8944        self.port = port if port is not None else 0
8945        self.port_override = port_override if port_override is not None else 0
8946        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8947        '''
8948         ID of the secret store containing credentials for this resource, if any.
8949        '''
8950        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8951        '''
8952         Tags is a map of key, value pairs.
8953        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8969    def to_dict(self):
8970        return {
8971            'bind_interface': self.bind_interface,
8972            'egress_filter': self.egress_filter,
8973            'healthy': self.healthy,
8974            'hostname': self.hostname,
8975            'id': self.id,
8976            'name': self.name,
8977            'port': self.port,
8978            'port_override': self.port_override,
8979            'secret_store_id': self.secret_store_id,
8980            'tags': self.tags,
8981        }
@classmethod
def from_dict(cls, d)
8983    @classmethod
8984    def from_dict(cls, d):
8985        return cls(
8986            bind_interface=d.get('bind_interface'),
8987            egress_filter=d.get('egress_filter'),
8988            healthy=d.get('healthy'),
8989            hostname=d.get('hostname'),
8990            id=d.get('id'),
8991            name=d.get('name'),
8992            port=d.get('port'),
8993            port_override=d.get('port_override'),
8994            secret_store_id=d.get('secret_store_id'),
8995            tags=d.get('tags'),
8996        )
class Redis:
8999class Redis:
9000    __slots__ = [
9001        'bind_interface',
9002        'egress_filter',
9003        'healthy',
9004        'hostname',
9005        'id',
9006        'name',
9007        'password',
9008        'port',
9009        'port_override',
9010        'secret_store_id',
9011        'tags',
9012    ]
9013
9014    def __init__(
9015        self,
9016        bind_interface=None,
9017        egress_filter=None,
9018        healthy=None,
9019        hostname=None,
9020        id=None,
9021        name=None,
9022        password=None,
9023        port=None,
9024        port_override=None,
9025        secret_store_id=None,
9026        tags=None,
9027    ):
9028        self.bind_interface = bind_interface if bind_interface is not None else ''
9029        '''
9030         Bind interface
9031        '''
9032        self.egress_filter = egress_filter if egress_filter is not None else ''
9033        '''
9034         A filter applied to the routing logic to pin datasource to nodes.
9035        '''
9036        self.healthy = healthy if healthy is not None else False
9037        '''
9038         True if the datasource is reachable and the credentials are valid.
9039        '''
9040        self.hostname = hostname if hostname is not None else ''
9041        self.id = id if id is not None else ''
9042        '''
9043         Unique identifier of the Resource.
9044        '''
9045        self.name = name if name is not None else ''
9046        '''
9047         Unique human-readable name of the Resource.
9048        '''
9049        self.password = password if password is not None else ''
9050        self.port = port if port is not None else 0
9051        self.port_override = port_override if port_override is not None else 0
9052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9053        '''
9054         ID of the secret store containing credentials for this resource, if any.
9055        '''
9056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9057        '''
9058         Tags is a map of key, value pairs.
9059        '''
9060
9061    def __repr__(self):
9062        return '<sdm.Redis ' + \
9063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9065            'healthy: ' + repr(self.healthy) + ' ' +\
9066            'hostname: ' + repr(self.hostname) + ' ' +\
9067            'id: ' + repr(self.id) + ' ' +\
9068            'name: ' + repr(self.name) + ' ' +\
9069            'password: ' + repr(self.password) + ' ' +\
9070            'port: ' + repr(self.port) + ' ' +\
9071            'port_override: ' + repr(self.port_override) + ' ' +\
9072            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9073            'tags: ' + repr(self.tags) + ' ' +\
9074            '>'
9075
9076    def to_dict(self):
9077        return {
9078            'bind_interface': self.bind_interface,
9079            'egress_filter': self.egress_filter,
9080            'healthy': self.healthy,
9081            'hostname': self.hostname,
9082            'id': self.id,
9083            'name': self.name,
9084            'password': self.password,
9085            'port': self.port,
9086            'port_override': self.port_override,
9087            'secret_store_id': self.secret_store_id,
9088            'tags': self.tags,
9089        }
9090
9091    @classmethod
9092    def from_dict(cls, d):
9093        return cls(
9094            bind_interface=d.get('bind_interface'),
9095            egress_filter=d.get('egress_filter'),
9096            healthy=d.get('healthy'),
9097            hostname=d.get('hostname'),
9098            id=d.get('id'),
9099            name=d.get('name'),
9100            password=d.get('password'),
9101            port=d.get('port'),
9102            port_override=d.get('port_override'),
9103            secret_store_id=d.get('secret_store_id'),
9104            tags=d.get('tags'),
9105        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
9014    def __init__(
9015        self,
9016        bind_interface=None,
9017        egress_filter=None,
9018        healthy=None,
9019        hostname=None,
9020        id=None,
9021        name=None,
9022        password=None,
9023        port=None,
9024        port_override=None,
9025        secret_store_id=None,
9026        tags=None,
9027    ):
9028        self.bind_interface = bind_interface if bind_interface is not None else ''
9029        '''
9030         Bind interface
9031        '''
9032        self.egress_filter = egress_filter if egress_filter is not None else ''
9033        '''
9034         A filter applied to the routing logic to pin datasource to nodes.
9035        '''
9036        self.healthy = healthy if healthy is not None else False
9037        '''
9038         True if the datasource is reachable and the credentials are valid.
9039        '''
9040        self.hostname = hostname if hostname is not None else ''
9041        self.id = id if id is not None else ''
9042        '''
9043         Unique identifier of the Resource.
9044        '''
9045        self.name = name if name is not None else ''
9046        '''
9047         Unique human-readable name of the Resource.
9048        '''
9049        self.password = password if password is not None else ''
9050        self.port = port if port is not None else 0
9051        self.port_override = port_override if port_override is not None else 0
9052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9053        '''
9054         ID of the secret store containing credentials for this resource, if any.
9055        '''
9056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9057        '''
9058         Tags is a map of key, value pairs.
9059        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9076    def to_dict(self):
9077        return {
9078            'bind_interface': self.bind_interface,
9079            'egress_filter': self.egress_filter,
9080            'healthy': self.healthy,
9081            'hostname': self.hostname,
9082            'id': self.id,
9083            'name': self.name,
9084            'password': self.password,
9085            'port': self.port,
9086            'port_override': self.port_override,
9087            'secret_store_id': self.secret_store_id,
9088            'tags': self.tags,
9089        }
@classmethod
def from_dict(cls, d)
9091    @classmethod
9092    def from_dict(cls, d):
9093        return cls(
9094            bind_interface=d.get('bind_interface'),
9095            egress_filter=d.get('egress_filter'),
9096            healthy=d.get('healthy'),
9097            hostname=d.get('hostname'),
9098            id=d.get('id'),
9099            name=d.get('name'),
9100            password=d.get('password'),
9101            port=d.get('port'),
9102            port_override=d.get('port_override'),
9103            secret_store_id=d.get('secret_store_id'),
9104            tags=d.get('tags'),
9105        )
class Redshift:
9108class Redshift:
9109    __slots__ = [
9110        'bind_interface',
9111        'database',
9112        'egress_filter',
9113        'healthy',
9114        'hostname',
9115        'id',
9116        'name',
9117        'override_database',
9118        'password',
9119        'port',
9120        'port_override',
9121        'secret_store_id',
9122        'tags',
9123        'username',
9124    ]
9125
9126    def __init__(
9127        self,
9128        bind_interface=None,
9129        database=None,
9130        egress_filter=None,
9131        healthy=None,
9132        hostname=None,
9133        id=None,
9134        name=None,
9135        override_database=None,
9136        password=None,
9137        port=None,
9138        port_override=None,
9139        secret_store_id=None,
9140        tags=None,
9141        username=None,
9142    ):
9143        self.bind_interface = bind_interface if bind_interface is not None else ''
9144        '''
9145         Bind interface
9146        '''
9147        self.database = database if database is not None else ''
9148        self.egress_filter = egress_filter if egress_filter is not None else ''
9149        '''
9150         A filter applied to the routing logic to pin datasource to nodes.
9151        '''
9152        self.healthy = healthy if healthy is not None else False
9153        '''
9154         True if the datasource is reachable and the credentials are valid.
9155        '''
9156        self.hostname = hostname if hostname is not None else ''
9157        self.id = id if id is not None else ''
9158        '''
9159         Unique identifier of the Resource.
9160        '''
9161        self.name = name if name is not None else ''
9162        '''
9163         Unique human-readable name of the Resource.
9164        '''
9165        self.override_database = override_database if override_database is not None else False
9166        self.password = password if password is not None else ''
9167        self.port = port if port is not None else 0
9168        self.port_override = port_override if port_override is not None else 0
9169        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9170        '''
9171         ID of the secret store containing credentials for this resource, if any.
9172        '''
9173        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9174        '''
9175         Tags is a map of key, value pairs.
9176        '''
9177        self.username = username if username is not None else ''
9178
9179    def __repr__(self):
9180        return '<sdm.Redshift ' + \
9181            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9182            'database: ' + repr(self.database) + ' ' +\
9183            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9184            'healthy: ' + repr(self.healthy) + ' ' +\
9185            'hostname: ' + repr(self.hostname) + ' ' +\
9186            'id: ' + repr(self.id) + ' ' +\
9187            'name: ' + repr(self.name) + ' ' +\
9188            'override_database: ' + repr(self.override_database) + ' ' +\
9189            'password: ' + repr(self.password) + ' ' +\
9190            'port: ' + repr(self.port) + ' ' +\
9191            'port_override: ' + repr(self.port_override) + ' ' +\
9192            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9193            'tags: ' + repr(self.tags) + ' ' +\
9194            'username: ' + repr(self.username) + ' ' +\
9195            '>'
9196
9197    def to_dict(self):
9198        return {
9199            'bind_interface': self.bind_interface,
9200            'database': self.database,
9201            'egress_filter': self.egress_filter,
9202            'healthy': self.healthy,
9203            'hostname': self.hostname,
9204            'id': self.id,
9205            'name': self.name,
9206            'override_database': self.override_database,
9207            'password': self.password,
9208            'port': self.port,
9209            'port_override': self.port_override,
9210            'secret_store_id': self.secret_store_id,
9211            'tags': self.tags,
9212            'username': self.username,
9213        }
9214
9215    @classmethod
9216    def from_dict(cls, d):
9217        return cls(
9218            bind_interface=d.get('bind_interface'),
9219            database=d.get('database'),
9220            egress_filter=d.get('egress_filter'),
9221            healthy=d.get('healthy'),
9222            hostname=d.get('hostname'),
9223            id=d.get('id'),
9224            name=d.get('name'),
9225            override_database=d.get('override_database'),
9226            password=d.get('password'),
9227            port=d.get('port'),
9228            port_override=d.get('port_override'),
9229            secret_store_id=d.get('secret_store_id'),
9230            tags=d.get('tags'),
9231            username=d.get('username'),
9232        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9126    def __init__(
9127        self,
9128        bind_interface=None,
9129        database=None,
9130        egress_filter=None,
9131        healthy=None,
9132        hostname=None,
9133        id=None,
9134        name=None,
9135        override_database=None,
9136        password=None,
9137        port=None,
9138        port_override=None,
9139        secret_store_id=None,
9140        tags=None,
9141        username=None,
9142    ):
9143        self.bind_interface = bind_interface if bind_interface is not None else ''
9144        '''
9145         Bind interface
9146        '''
9147        self.database = database if database is not None else ''
9148        self.egress_filter = egress_filter if egress_filter is not None else ''
9149        '''
9150         A filter applied to the routing logic to pin datasource to nodes.
9151        '''
9152        self.healthy = healthy if healthy is not None else False
9153        '''
9154         True if the datasource is reachable and the credentials are valid.
9155        '''
9156        self.hostname = hostname if hostname is not None else ''
9157        self.id = id if id is not None else ''
9158        '''
9159         Unique identifier of the Resource.
9160        '''
9161        self.name = name if name is not None else ''
9162        '''
9163         Unique human-readable name of the Resource.
9164        '''
9165        self.override_database = override_database if override_database is not None else False
9166        self.password = password if password is not None else ''
9167        self.port = port if port is not None else 0
9168        self.port_override = port_override if port_override is not None else 0
9169        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9170        '''
9171         ID of the secret store containing credentials for this resource, if any.
9172        '''
9173        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9174        '''
9175         Tags is a map of key, value pairs.
9176        '''
9177        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9197    def to_dict(self):
9198        return {
9199            'bind_interface': self.bind_interface,
9200            'database': self.database,
9201            'egress_filter': self.egress_filter,
9202            'healthy': self.healthy,
9203            'hostname': self.hostname,
9204            'id': self.id,
9205            'name': self.name,
9206            'override_database': self.override_database,
9207            'password': self.password,
9208            'port': self.port,
9209            'port_override': self.port_override,
9210            'secret_store_id': self.secret_store_id,
9211            'tags': self.tags,
9212            'username': self.username,
9213        }
@classmethod
def from_dict(cls, d)
9215    @classmethod
9216    def from_dict(cls, d):
9217        return cls(
9218            bind_interface=d.get('bind_interface'),
9219            database=d.get('database'),
9220            egress_filter=d.get('egress_filter'),
9221            healthy=d.get('healthy'),
9222            hostname=d.get('hostname'),
9223            id=d.get('id'),
9224            name=d.get('name'),
9225            override_database=d.get('override_database'),
9226            password=d.get('password'),
9227            port=d.get('port'),
9228            port_override=d.get('port_override'),
9229            secret_store_id=d.get('secret_store_id'),
9230            tags=d.get('tags'),
9231            username=d.get('username'),
9232        )
class Relay:
9235class Relay:
9236    '''
9237         Relay represents a StrongDM CLI installation running in relay mode.
9238    '''
9239    __slots__ = [
9240        'gateway_filter',
9241        'id',
9242        'name',
9243        'state',
9244        'tags',
9245    ]
9246
9247    def __init__(
9248        self,
9249        gateway_filter=None,
9250        id=None,
9251        name=None,
9252        state=None,
9253        tags=None,
9254    ):
9255        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9256        '''
9257         GatewayFilter can be used to restrict the peering between relays and
9258         gateways.
9259        '''
9260        self.id = id if id is not None else ''
9261        '''
9262         Unique identifier of the Relay.
9263        '''
9264        self.name = name if name is not None else ''
9265        '''
9266         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9267        '''
9268        self.state = state if state is not None else ''
9269        '''
9270         The current state of the relay. One of: "new", "verifying_restart",
9271         "awaiting_restart", "restarting", "started", "stopped", "dead",
9272         "unknown".
9273        '''
9274        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9275        '''
9276         Tags is a map of key, value pairs.
9277        '''
9278
9279    def __repr__(self):
9280        return '<sdm.Relay ' + \
9281            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9282            'id: ' + repr(self.id) + ' ' +\
9283            'name: ' + repr(self.name) + ' ' +\
9284            'state: ' + repr(self.state) + ' ' +\
9285            'tags: ' + repr(self.tags) + ' ' +\
9286            '>'
9287
9288    def to_dict(self):
9289        return {
9290            'gateway_filter': self.gateway_filter,
9291            'id': self.id,
9292            'name': self.name,
9293            'state': self.state,
9294            'tags': self.tags,
9295        }
9296
9297    @classmethod
9298    def from_dict(cls, d):
9299        return cls(
9300            gateway_filter=d.get('gateway_filter'),
9301            id=d.get('id'),
9302            name=d.get('name'),
9303            state=d.get('state'),
9304            tags=d.get('tags'),
9305        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
9247    def __init__(
9248        self,
9249        gateway_filter=None,
9250        id=None,
9251        name=None,
9252        state=None,
9253        tags=None,
9254    ):
9255        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9256        '''
9257         GatewayFilter can be used to restrict the peering between relays and
9258         gateways.
9259        '''
9260        self.id = id if id is not None else ''
9261        '''
9262         Unique identifier of the Relay.
9263        '''
9264        self.name = name if name is not None else ''
9265        '''
9266         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9267        '''
9268        self.state = state if state is not None else ''
9269        '''
9270         The current state of the relay. One of: "new", "verifying_restart",
9271         "awaiting_restart", "restarting", "started", "stopped", "dead",
9272         "unknown".
9273        '''
9274        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9275        '''
9276         Tags is a map of key, value pairs.
9277        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
9288    def to_dict(self):
9289        return {
9290            'gateway_filter': self.gateway_filter,
9291            'id': self.id,
9292            'name': self.name,
9293            'state': self.state,
9294            'tags': self.tags,
9295        }
@classmethod
def from_dict(cls, d)
9297    @classmethod
9298    def from_dict(cls, d):
9299        return cls(
9300            gateway_filter=d.get('gateway_filter'),
9301            id=d.get('id'),
9302            name=d.get('name'),
9303            state=d.get('state'),
9304            tags=d.get('tags'),
9305        )
class RemoteIdentity:
9308class RemoteIdentity:
9309    '''
9310         RemoteIdentities define the username to be used for a specific account
9311     when connecting to a remote resource using that group.
9312    '''
9313    __slots__ = [
9314        'account_id',
9315        'id',
9316        'remote_identity_group_id',
9317        'username',
9318    ]
9319
9320    def __init__(
9321        self,
9322        account_id=None,
9323        id=None,
9324        remote_identity_group_id=None,
9325        username=None,
9326    ):
9327        self.account_id = account_id if account_id is not None else ''
9328        '''
9329         The account for this remote identity.
9330        '''
9331        self.id = id if id is not None else ''
9332        '''
9333         Unique identifier of the RemoteIdentity.
9334        '''
9335        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9336        '''
9337         The remote identity group.
9338        '''
9339        self.username = username if username is not None else ''
9340        '''
9341         The username to be used as the remote identity for this account.
9342        '''
9343
9344    def __repr__(self):
9345        return '<sdm.RemoteIdentity ' + \
9346            'account_id: ' + repr(self.account_id) + ' ' +\
9347            'id: ' + repr(self.id) + ' ' +\
9348            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9349            'username: ' + repr(self.username) + ' ' +\
9350            '>'
9351
9352    def to_dict(self):
9353        return {
9354            'account_id': self.account_id,
9355            'id': self.id,
9356            'remote_identity_group_id': self.remote_identity_group_id,
9357            'username': self.username,
9358        }
9359
9360    @classmethod
9361    def from_dict(cls, d):
9362        return cls(
9363            account_id=d.get('account_id'),
9364            id=d.get('id'),
9365            remote_identity_group_id=d.get('remote_identity_group_id'),
9366            username=d.get('username'),
9367        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9320    def __init__(
9321        self,
9322        account_id=None,
9323        id=None,
9324        remote_identity_group_id=None,
9325        username=None,
9326    ):
9327        self.account_id = account_id if account_id is not None else ''
9328        '''
9329         The account for this remote identity.
9330        '''
9331        self.id = id if id is not None else ''
9332        '''
9333         Unique identifier of the RemoteIdentity.
9334        '''
9335        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9336        '''
9337         The remote identity group.
9338        '''
9339        self.username = username if username is not None else ''
9340        '''
9341         The username to be used as the remote identity for this account.
9342        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9352    def to_dict(self):
9353        return {
9354            'account_id': self.account_id,
9355            'id': self.id,
9356            'remote_identity_group_id': self.remote_identity_group_id,
9357            'username': self.username,
9358        }
@classmethod
def from_dict(cls, d)
9360    @classmethod
9361    def from_dict(cls, d):
9362        return cls(
9363            account_id=d.get('account_id'),
9364            id=d.get('id'),
9365            remote_identity_group_id=d.get('remote_identity_group_id'),
9366            username=d.get('username'),
9367        )
class RemoteIdentityCreateResponse:
9370class RemoteIdentityCreateResponse:
9371    '''
9372         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9373    '''
9374    __slots__ = [
9375        'meta',
9376        'rate_limit',
9377        'remote_identity',
9378    ]
9379
9380    def __init__(
9381        self,
9382        meta=None,
9383        rate_limit=None,
9384        remote_identity=None,
9385    ):
9386        self.meta = meta if meta is not None else None
9387        '''
9388         Reserved for future use.
9389        '''
9390        self.rate_limit = rate_limit if rate_limit is not None else None
9391        '''
9392         Rate limit information.
9393        '''
9394        self.remote_identity = remote_identity if remote_identity is not None else None
9395        '''
9396         The created RemoteIdentity.
9397        '''
9398
9399    def __repr__(self):
9400        return '<sdm.RemoteIdentityCreateResponse ' + \
9401            'meta: ' + repr(self.meta) + ' ' +\
9402            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9403            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9404            '>'
9405
9406    def to_dict(self):
9407        return {
9408            'meta': self.meta,
9409            'rate_limit': self.rate_limit,
9410            'remote_identity': self.remote_identity,
9411        }
9412
9413    @classmethod
9414    def from_dict(cls, d):
9415        return cls(
9416            meta=d.get('meta'),
9417            rate_limit=d.get('rate_limit'),
9418            remote_identity=d.get('remote_identity'),
9419        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9380    def __init__(
9381        self,
9382        meta=None,
9383        rate_limit=None,
9384        remote_identity=None,
9385    ):
9386        self.meta = meta if meta is not None else None
9387        '''
9388         Reserved for future use.
9389        '''
9390        self.rate_limit = rate_limit if rate_limit is not None else None
9391        '''
9392         Rate limit information.
9393        '''
9394        self.remote_identity = remote_identity if remote_identity is not None else None
9395        '''
9396         The created RemoteIdentity.
9397        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9406    def to_dict(self):
9407        return {
9408            'meta': self.meta,
9409            'rate_limit': self.rate_limit,
9410            'remote_identity': self.remote_identity,
9411        }
@classmethod
def from_dict(cls, d)
9413    @classmethod
9414    def from_dict(cls, d):
9415        return cls(
9416            meta=d.get('meta'),
9417            rate_limit=d.get('rate_limit'),
9418            remote_identity=d.get('remote_identity'),
9419        )
class RemoteIdentityDeleteResponse:
9422class RemoteIdentityDeleteResponse:
9423    '''
9424         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
9425    '''
9426    __slots__ = [
9427        'meta',
9428        'rate_limit',
9429    ]
9430
9431    def __init__(
9432        self,
9433        meta=None,
9434        rate_limit=None,
9435    ):
9436        self.meta = meta if meta is not None else None
9437        '''
9438         Reserved for future use.
9439        '''
9440        self.rate_limit = rate_limit if rate_limit is not None else None
9441        '''
9442         Rate limit information.
9443        '''
9444
9445    def __repr__(self):
9446        return '<sdm.RemoteIdentityDeleteResponse ' + \
9447            'meta: ' + repr(self.meta) + ' ' +\
9448            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9449            '>'
9450
9451    def to_dict(self):
9452        return {
9453            'meta': self.meta,
9454            'rate_limit': self.rate_limit,
9455        }
9456
9457    @classmethod
9458    def from_dict(cls, d):
9459        return cls(
9460            meta=d.get('meta'),
9461            rate_limit=d.get('rate_limit'),
9462        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
9431    def __init__(
9432        self,
9433        meta=None,
9434        rate_limit=None,
9435    ):
9436        self.meta = meta if meta is not None else None
9437        '''
9438         Reserved for future use.
9439        '''
9440        self.rate_limit = rate_limit if rate_limit is not None else None
9441        '''
9442         Rate limit information.
9443        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9451    def to_dict(self):
9452        return {
9453            'meta': self.meta,
9454            'rate_limit': self.rate_limit,
9455        }
@classmethod
def from_dict(cls, d)
9457    @classmethod
9458    def from_dict(cls, d):
9459        return cls(
9460            meta=d.get('meta'),
9461            rate_limit=d.get('rate_limit'),
9462        )
class RemoteIdentityGetResponse:
9465class RemoteIdentityGetResponse:
9466    '''
9467         RemoteIdentityGetResponse returns a requested RemoteIdentity.
9468    '''
9469    __slots__ = [
9470        'meta',
9471        'rate_limit',
9472        'remote_identity',
9473    ]
9474
9475    def __init__(
9476        self,
9477        meta=None,
9478        rate_limit=None,
9479        remote_identity=None,
9480    ):
9481        self.meta = meta if meta is not None else None
9482        '''
9483         Reserved for future use.
9484        '''
9485        self.rate_limit = rate_limit if rate_limit is not None else None
9486        '''
9487         Rate limit information.
9488        '''
9489        self.remote_identity = remote_identity if remote_identity is not None else None
9490        '''
9491         The requested RemoteIdentity.
9492        '''
9493
9494    def __repr__(self):
9495        return '<sdm.RemoteIdentityGetResponse ' + \
9496            'meta: ' + repr(self.meta) + ' ' +\
9497            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9498            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9499            '>'
9500
9501    def to_dict(self):
9502        return {
9503            'meta': self.meta,
9504            'rate_limit': self.rate_limit,
9505            'remote_identity': self.remote_identity,
9506        }
9507
9508    @classmethod
9509    def from_dict(cls, d):
9510        return cls(
9511            meta=d.get('meta'),
9512            rate_limit=d.get('rate_limit'),
9513            remote_identity=d.get('remote_identity'),
9514        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
9475    def __init__(
9476        self,
9477        meta=None,
9478        rate_limit=None,
9479        remote_identity=None,
9480    ):
9481        self.meta = meta if meta is not None else None
9482        '''
9483         Reserved for future use.
9484        '''
9485        self.rate_limit = rate_limit if rate_limit is not None else None
9486        '''
9487         Rate limit information.
9488        '''
9489        self.remote_identity = remote_identity if remote_identity is not None else None
9490        '''
9491         The requested RemoteIdentity.
9492        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
9501    def to_dict(self):
9502        return {
9503            'meta': self.meta,
9504            'rate_limit': self.rate_limit,
9505            'remote_identity': self.remote_identity,
9506        }
@classmethod
def from_dict(cls, d)
9508    @classmethod
9509    def from_dict(cls, d):
9510        return cls(
9511            meta=d.get('meta'),
9512            rate_limit=d.get('rate_limit'),
9513            remote_identity=d.get('remote_identity'),
9514        )
class RemoteIdentityGroup:
9517class RemoteIdentityGroup:
9518    '''
9519         A RemoteIdentityGroup defines a group of remote identities.
9520    '''
9521    __slots__ = [
9522        'id',
9523        'name',
9524    ]
9525
9526    def __init__(
9527        self,
9528        id=None,
9529        name=None,
9530    ):
9531        self.id = id if id is not None else ''
9532        '''
9533         Unique identifier of the RemoteIdentityGroup.
9534        '''
9535        self.name = name if name is not None else ''
9536        '''
9537         Unique human-readable name of the RemoteIdentityGroup.
9538        '''
9539
9540    def __repr__(self):
9541        return '<sdm.RemoteIdentityGroup ' + \
9542            'id: ' + repr(self.id) + ' ' +\
9543            'name: ' + repr(self.name) + ' ' +\
9544            '>'
9545
9546    def to_dict(self):
9547        return {
9548            'id': self.id,
9549            'name': self.name,
9550        }
9551
9552    @classmethod
9553    def from_dict(cls, d):
9554        return cls(
9555            id=d.get('id'),
9556            name=d.get('name'),
9557        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
9526    def __init__(
9527        self,
9528        id=None,
9529        name=None,
9530    ):
9531        self.id = id if id is not None else ''
9532        '''
9533         Unique identifier of the RemoteIdentityGroup.
9534        '''
9535        self.name = name if name is not None else ''
9536        '''
9537         Unique human-readable name of the RemoteIdentityGroup.
9538        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
9546    def to_dict(self):
9547        return {
9548            'id': self.id,
9549            'name': self.name,
9550        }
@classmethod
def from_dict(cls, d)
9552    @classmethod
9553    def from_dict(cls, d):
9554        return cls(
9555            id=d.get('id'),
9556            name=d.get('name'),
9557        )
class RemoteIdentityGroupGetResponse:
9560class RemoteIdentityGroupGetResponse:
9561    '''
9562         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
9563    '''
9564    __slots__ = [
9565        'meta',
9566        'rate_limit',
9567        'remote_identity_group',
9568    ]
9569
9570    def __init__(
9571        self,
9572        meta=None,
9573        rate_limit=None,
9574        remote_identity_group=None,
9575    ):
9576        self.meta = meta if meta is not None else None
9577        '''
9578         Reserved for future use.
9579        '''
9580        self.rate_limit = rate_limit if rate_limit is not None else None
9581        '''
9582         Rate limit information.
9583        '''
9584        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9585        '''
9586         The requested RemoteIdentityGroup.
9587        '''
9588
9589    def __repr__(self):
9590        return '<sdm.RemoteIdentityGroupGetResponse ' + \
9591            'meta: ' + repr(self.meta) + ' ' +\
9592            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9593            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
9594            '>'
9595
9596    def to_dict(self):
9597        return {
9598            'meta': self.meta,
9599            'rate_limit': self.rate_limit,
9600            'remote_identity_group': self.remote_identity_group,
9601        }
9602
9603    @classmethod
9604    def from_dict(cls, d):
9605        return cls(
9606            meta=d.get('meta'),
9607            rate_limit=d.get('rate_limit'),
9608            remote_identity_group=d.get('remote_identity_group'),
9609        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
9570    def __init__(
9571        self,
9572        meta=None,
9573        rate_limit=None,
9574        remote_identity_group=None,
9575    ):
9576        self.meta = meta if meta is not None else None
9577        '''
9578         Reserved for future use.
9579        '''
9580        self.rate_limit = rate_limit if rate_limit is not None else None
9581        '''
9582         Rate limit information.
9583        '''
9584        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9585        '''
9586         The requested RemoteIdentityGroup.
9587        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
9596    def to_dict(self):
9597        return {
9598            'meta': self.meta,
9599            'rate_limit': self.rate_limit,
9600            'remote_identity_group': self.remote_identity_group,
9601        }
@classmethod
def from_dict(cls, d)
9603    @classmethod
9604    def from_dict(cls, d):
9605        return cls(
9606            meta=d.get('meta'),
9607            rate_limit=d.get('rate_limit'),
9608            remote_identity_group=d.get('remote_identity_group'),
9609        )
class RemoteIdentityUpdateResponse:
9612class RemoteIdentityUpdateResponse:
9613    '''
9614         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
9615     a RemoteIdentityUpdateRequest.
9616    '''
9617    __slots__ = [
9618        'meta',
9619        'rate_limit',
9620        'remote_identity',
9621    ]
9622
9623    def __init__(
9624        self,
9625        meta=None,
9626        rate_limit=None,
9627        remote_identity=None,
9628    ):
9629        self.meta = meta if meta is not None else None
9630        '''
9631         Reserved for future use.
9632        '''
9633        self.rate_limit = rate_limit if rate_limit is not None else None
9634        '''
9635         Rate limit information.
9636        '''
9637        self.remote_identity = remote_identity if remote_identity is not None else None
9638        '''
9639         The updated RemoteIdentity.
9640        '''
9641
9642    def __repr__(self):
9643        return '<sdm.RemoteIdentityUpdateResponse ' + \
9644            'meta: ' + repr(self.meta) + ' ' +\
9645            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9646            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9647            '>'
9648
9649    def to_dict(self):
9650        return {
9651            'meta': self.meta,
9652            'rate_limit': self.rate_limit,
9653            'remote_identity': self.remote_identity,
9654        }
9655
9656    @classmethod
9657    def from_dict(cls, d):
9658        return cls(
9659            meta=d.get('meta'),
9660            rate_limit=d.get('rate_limit'),
9661            remote_identity=d.get('remote_identity'),
9662        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
9623    def __init__(
9624        self,
9625        meta=None,
9626        rate_limit=None,
9627        remote_identity=None,
9628    ):
9629        self.meta = meta if meta is not None else None
9630        '''
9631         Reserved for future use.
9632        '''
9633        self.rate_limit = rate_limit if rate_limit is not None else None
9634        '''
9635         Rate limit information.
9636        '''
9637        self.remote_identity = remote_identity if remote_identity is not None else None
9638        '''
9639         The updated RemoteIdentity.
9640        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
9649    def to_dict(self):
9650        return {
9651            'meta': self.meta,
9652            'rate_limit': self.rate_limit,
9653            'remote_identity': self.remote_identity,
9654        }
@classmethod
def from_dict(cls, d)
9656    @classmethod
9657    def from_dict(cls, d):
9658        return cls(
9659            meta=d.get('meta'),
9660            rate_limit=d.get('rate_limit'),
9661            remote_identity=d.get('remote_identity'),
9662        )
class ResourceCreateResponse:
9665class ResourceCreateResponse:
9666    '''
9667         ResourceCreateResponse reports how the Resources were created in the system.
9668    '''
9669    __slots__ = [
9670        'meta',
9671        'rate_limit',
9672        'resource',
9673    ]
9674
9675    def __init__(
9676        self,
9677        meta=None,
9678        rate_limit=None,
9679        resource=None,
9680    ):
9681        self.meta = meta if meta is not None else None
9682        '''
9683         Reserved for future use.
9684        '''
9685        self.rate_limit = rate_limit if rate_limit is not None else None
9686        '''
9687         Rate limit information.
9688        '''
9689        self.resource = resource if resource is not None else None
9690        '''
9691         The created Resource.
9692        '''
9693
9694    def __repr__(self):
9695        return '<sdm.ResourceCreateResponse ' + \
9696            'meta: ' + repr(self.meta) + ' ' +\
9697            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9698            'resource: ' + repr(self.resource) + ' ' +\
9699            '>'
9700
9701    def to_dict(self):
9702        return {
9703            'meta': self.meta,
9704            'rate_limit': self.rate_limit,
9705            'resource': self.resource,
9706        }
9707
9708    @classmethod
9709    def from_dict(cls, d):
9710        return cls(
9711            meta=d.get('meta'),
9712            rate_limit=d.get('rate_limit'),
9713            resource=d.get('resource'),
9714        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
9675    def __init__(
9676        self,
9677        meta=None,
9678        rate_limit=None,
9679        resource=None,
9680    ):
9681        self.meta = meta if meta is not None else None
9682        '''
9683         Reserved for future use.
9684        '''
9685        self.rate_limit = rate_limit if rate_limit is not None else None
9686        '''
9687         Rate limit information.
9688        '''
9689        self.resource = resource if resource is not None else None
9690        '''
9691         The created Resource.
9692        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
9701    def to_dict(self):
9702        return {
9703            'meta': self.meta,
9704            'rate_limit': self.rate_limit,
9705            'resource': self.resource,
9706        }
@classmethod
def from_dict(cls, d)
9708    @classmethod
9709    def from_dict(cls, d):
9710        return cls(
9711            meta=d.get('meta'),
9712            rate_limit=d.get('rate_limit'),
9713            resource=d.get('resource'),
9714        )
class ResourceDeleteResponse:
9717class ResourceDeleteResponse:
9718    '''
9719         ResourceDeleteResponse returns information about a Resource that was deleted.
9720    '''
9721    __slots__ = [
9722        'meta',
9723        'rate_limit',
9724    ]
9725
9726    def __init__(
9727        self,
9728        meta=None,
9729        rate_limit=None,
9730    ):
9731        self.meta = meta if meta is not None else None
9732        '''
9733         Reserved for future use.
9734        '''
9735        self.rate_limit = rate_limit if rate_limit is not None else None
9736        '''
9737         Rate limit information.
9738        '''
9739
9740    def __repr__(self):
9741        return '<sdm.ResourceDeleteResponse ' + \
9742            'meta: ' + repr(self.meta) + ' ' +\
9743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9744            '>'
9745
9746    def to_dict(self):
9747        return {
9748            'meta': self.meta,
9749            'rate_limit': self.rate_limit,
9750        }
9751
9752    @classmethod
9753    def from_dict(cls, d):
9754        return cls(
9755            meta=d.get('meta'),
9756            rate_limit=d.get('rate_limit'),
9757        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
9726    def __init__(
9727        self,
9728        meta=None,
9729        rate_limit=None,
9730    ):
9731        self.meta = meta if meta is not None else None
9732        '''
9733         Reserved for future use.
9734        '''
9735        self.rate_limit = rate_limit if rate_limit is not None else None
9736        '''
9737         Rate limit information.
9738        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9746    def to_dict(self):
9747        return {
9748            'meta': self.meta,
9749            'rate_limit': self.rate_limit,
9750        }
@classmethod
def from_dict(cls, d)
9752    @classmethod
9753    def from_dict(cls, d):
9754        return cls(
9755            meta=d.get('meta'),
9756            rate_limit=d.get('rate_limit'),
9757        )
class ResourceGetResponse:
9760class ResourceGetResponse:
9761    '''
9762         ResourceGetResponse returns a requested Resource.
9763    '''
9764    __slots__ = [
9765        'meta',
9766        'rate_limit',
9767        'resource',
9768    ]
9769
9770    def __init__(
9771        self,
9772        meta=None,
9773        rate_limit=None,
9774        resource=None,
9775    ):
9776        self.meta = meta if meta is not None else None
9777        '''
9778         Reserved for future use.
9779        '''
9780        self.rate_limit = rate_limit if rate_limit is not None else None
9781        '''
9782         Rate limit information.
9783        '''
9784        self.resource = resource if resource is not None else None
9785        '''
9786         The requested Resource.
9787        '''
9788
9789    def __repr__(self):
9790        return '<sdm.ResourceGetResponse ' + \
9791            'meta: ' + repr(self.meta) + ' ' +\
9792            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9793            'resource: ' + repr(self.resource) + ' ' +\
9794            '>'
9795
9796    def to_dict(self):
9797        return {
9798            'meta': self.meta,
9799            'rate_limit': self.rate_limit,
9800            'resource': self.resource,
9801        }
9802
9803    @classmethod
9804    def from_dict(cls, d):
9805        return cls(
9806            meta=d.get('meta'),
9807            rate_limit=d.get('rate_limit'),
9808            resource=d.get('resource'),
9809        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
9770    def __init__(
9771        self,
9772        meta=None,
9773        rate_limit=None,
9774        resource=None,
9775    ):
9776        self.meta = meta if meta is not None else None
9777        '''
9778         Reserved for future use.
9779        '''
9780        self.rate_limit = rate_limit if rate_limit is not None else None
9781        '''
9782         Rate limit information.
9783        '''
9784        self.resource = resource if resource is not None else None
9785        '''
9786         The requested Resource.
9787        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
9796    def to_dict(self):
9797        return {
9798            'meta': self.meta,
9799            'rate_limit': self.rate_limit,
9800            'resource': self.resource,
9801        }
@classmethod
def from_dict(cls, d)
9803    @classmethod
9804    def from_dict(cls, d):
9805        return cls(
9806            meta=d.get('meta'),
9807            rate_limit=d.get('rate_limit'),
9808            resource=d.get('resource'),
9809        )
class ResourceUpdateResponse:
9812class ResourceUpdateResponse:
9813    '''
9814         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
9815     a ResourceUpdateRequest.
9816    '''
9817    __slots__ = [
9818        'meta',
9819        'rate_limit',
9820        'resource',
9821    ]
9822
9823    def __init__(
9824        self,
9825        meta=None,
9826        rate_limit=None,
9827        resource=None,
9828    ):
9829        self.meta = meta if meta is not None else None
9830        '''
9831         Reserved for future use.
9832        '''
9833        self.rate_limit = rate_limit if rate_limit is not None else None
9834        '''
9835         Rate limit information.
9836        '''
9837        self.resource = resource if resource is not None else None
9838        '''
9839         The updated Resource.
9840        '''
9841
9842    def __repr__(self):
9843        return '<sdm.ResourceUpdateResponse ' + \
9844            'meta: ' + repr(self.meta) + ' ' +\
9845            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9846            'resource: ' + repr(self.resource) + ' ' +\
9847            '>'
9848
9849    def to_dict(self):
9850        return {
9851            'meta': self.meta,
9852            'rate_limit': self.rate_limit,
9853            'resource': self.resource,
9854        }
9855
9856    @classmethod
9857    def from_dict(cls, d):
9858        return cls(
9859            meta=d.get('meta'),
9860            rate_limit=d.get('rate_limit'),
9861            resource=d.get('resource'),
9862        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
9823    def __init__(
9824        self,
9825        meta=None,
9826        rate_limit=None,
9827        resource=None,
9828    ):
9829        self.meta = meta if meta is not None else None
9830        '''
9831         Reserved for future use.
9832        '''
9833        self.rate_limit = rate_limit if rate_limit is not None else None
9834        '''
9835         Rate limit information.
9836        '''
9837        self.resource = resource if resource is not None else None
9838        '''
9839         The updated Resource.
9840        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
9849    def to_dict(self):
9850        return {
9851            'meta': self.meta,
9852            'rate_limit': self.rate_limit,
9853            'resource': self.resource,
9854        }
@classmethod
def from_dict(cls, d)
9856    @classmethod
9857    def from_dict(cls, d):
9858        return cls(
9859            meta=d.get('meta'),
9860            rate_limit=d.get('rate_limit'),
9861            resource=d.get('resource'),
9862        )
class Role:
9865class Role:
9866    '''
9867         A Role has a list of access rules which determine which Resources the members
9868     of the Role have access to. An Account can be a member of multiple Roles via
9869     AccountAttachments.
9870    '''
9871    __slots__ = [
9872        'access_rules',
9873        'id',
9874        'name',
9875        'tags',
9876    ]
9877
9878    def __init__(
9879        self,
9880        access_rules=None,
9881        id=None,
9882        name=None,
9883        tags=None,
9884    ):
9885        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9886        )
9887        '''
9888         AccessRules is a list of access rules defining the resources this Role has access to.
9889        '''
9890        self.id = id if id is not None else ''
9891        '''
9892         Unique identifier of the Role.
9893        '''
9894        self.name = name if name is not None else ''
9895        '''
9896         Unique human-readable name of the Role.
9897        '''
9898        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9899        '''
9900         Tags is a map of key, value pairs.
9901        '''
9902
9903    def __repr__(self):
9904        return '<sdm.Role ' + \
9905            'access_rules: ' + repr(self.access_rules) + ' ' +\
9906            'id: ' + repr(self.id) + ' ' +\
9907            'name: ' + repr(self.name) + ' ' +\
9908            'tags: ' + repr(self.tags) + ' ' +\
9909            '>'
9910
9911    def to_dict(self):
9912        return {
9913            'access_rules': self.access_rules,
9914            'id': self.id,
9915            'name': self.name,
9916            'tags': self.tags,
9917        }
9918
9919    @classmethod
9920    def from_dict(cls, d):
9921        return cls(
9922            access_rules=d.get('access_rules'),
9923            id=d.get('id'),
9924            name=d.get('name'),
9925            tags=d.get('tags'),
9926        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, name=None, tags=None)
9878    def __init__(
9879        self,
9880        access_rules=None,
9881        id=None,
9882        name=None,
9883        tags=None,
9884    ):
9885        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9886        )
9887        '''
9888         AccessRules is a list of access rules defining the resources this Role has access to.
9889        '''
9890        self.id = id if id is not None else ''
9891        '''
9892         Unique identifier of the Role.
9893        '''
9894        self.name = name if name is not None else ''
9895        '''
9896         Unique human-readable name of the Role.
9897        '''
9898        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9899        '''
9900         Tags is a map of key, value pairs.
9901        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9911    def to_dict(self):
9912        return {
9913            'access_rules': self.access_rules,
9914            'id': self.id,
9915            'name': self.name,
9916            'tags': self.tags,
9917        }
@classmethod
def from_dict(cls, d)
9919    @classmethod
9920    def from_dict(cls, d):
9921        return cls(
9922            access_rules=d.get('access_rules'),
9923            id=d.get('id'),
9924            name=d.get('name'),
9925            tags=d.get('tags'),
9926        )
class RoleCreateResponse:
9929class RoleCreateResponse:
9930    '''
9931         RoleCreateResponse reports how the Roles were created in the system. It can
9932     communicate partial successes or failures.
9933    '''
9934    __slots__ = [
9935        'meta',
9936        'rate_limit',
9937        'role',
9938    ]
9939
9940    def __init__(
9941        self,
9942        meta=None,
9943        rate_limit=None,
9944        role=None,
9945    ):
9946        self.meta = meta if meta is not None else None
9947        '''
9948         Reserved for future use.
9949        '''
9950        self.rate_limit = rate_limit if rate_limit is not None else None
9951        '''
9952         Rate limit information.
9953        '''
9954        self.role = role if role is not None else None
9955        '''
9956         The created Role.
9957        '''
9958
9959    def __repr__(self):
9960        return '<sdm.RoleCreateResponse ' + \
9961            'meta: ' + repr(self.meta) + ' ' +\
9962            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9963            'role: ' + repr(self.role) + ' ' +\
9964            '>'
9965
9966    def to_dict(self):
9967        return {
9968            'meta': self.meta,
9969            'rate_limit': self.rate_limit,
9970            'role': self.role,
9971        }
9972
9973    @classmethod
9974    def from_dict(cls, d):
9975        return cls(
9976            meta=d.get('meta'),
9977            rate_limit=d.get('rate_limit'),
9978            role=d.get('role'),
9979        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
9940    def __init__(
9941        self,
9942        meta=None,
9943        rate_limit=None,
9944        role=None,
9945    ):
9946        self.meta = meta if meta is not None else None
9947        '''
9948         Reserved for future use.
9949        '''
9950        self.rate_limit = rate_limit if rate_limit is not None else None
9951        '''
9952         Rate limit information.
9953        '''
9954        self.role = role if role is not None else None
9955        '''
9956         The created Role.
9957        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
9966    def to_dict(self):
9967        return {
9968            'meta': self.meta,
9969            'rate_limit': self.rate_limit,
9970            'role': self.role,
9971        }
@classmethod
def from_dict(cls, d)
9973    @classmethod
9974    def from_dict(cls, d):
9975        return cls(
9976            meta=d.get('meta'),
9977            rate_limit=d.get('rate_limit'),
9978            role=d.get('role'),
9979        )
class RoleDeleteResponse:
 9982class RoleDeleteResponse:
 9983    '''
 9984         RoleDeleteResponse returns information about a Role that was deleted.
 9985    '''
 9986    __slots__ = [
 9987        'meta',
 9988        'rate_limit',
 9989    ]
 9990
 9991    def __init__(
 9992        self,
 9993        meta=None,
 9994        rate_limit=None,
 9995    ):
 9996        self.meta = meta if meta is not None else None
 9997        '''
 9998         Reserved for future use.
 9999        '''
10000        self.rate_limit = rate_limit if rate_limit is not None else None
10001        '''
10002         Rate limit information.
10003        '''
10004
10005    def __repr__(self):
10006        return '<sdm.RoleDeleteResponse ' + \
10007            'meta: ' + repr(self.meta) + ' ' +\
10008            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10009            '>'
10010
10011    def to_dict(self):
10012        return {
10013            'meta': self.meta,
10014            'rate_limit': self.rate_limit,
10015        }
10016
10017    @classmethod
10018    def from_dict(cls, d):
10019        return cls(
10020            meta=d.get('meta'),
10021            rate_limit=d.get('rate_limit'),
10022        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
 9991    def __init__(
 9992        self,
 9993        meta=None,
 9994        rate_limit=None,
 9995    ):
 9996        self.meta = meta if meta is not None else None
 9997        '''
 9998         Reserved for future use.
 9999        '''
10000        self.rate_limit = rate_limit if rate_limit is not None else None
10001        '''
10002         Rate limit information.
10003        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10011    def to_dict(self):
10012        return {
10013            'meta': self.meta,
10014            'rate_limit': self.rate_limit,
10015        }
@classmethod
def from_dict(cls, d)
10017    @classmethod
10018    def from_dict(cls, d):
10019        return cls(
10020            meta=d.get('meta'),
10021            rate_limit=d.get('rate_limit'),
10022        )
class RoleGetResponse:
10025class RoleGetResponse:
10026    '''
10027         RoleGetResponse returns a requested Role.
10028    '''
10029    __slots__ = [
10030        'meta',
10031        'rate_limit',
10032        'role',
10033    ]
10034
10035    def __init__(
10036        self,
10037        meta=None,
10038        rate_limit=None,
10039        role=None,
10040    ):
10041        self.meta = meta if meta is not None else None
10042        '''
10043         Reserved for future use.
10044        '''
10045        self.rate_limit = rate_limit if rate_limit is not None else None
10046        '''
10047         Rate limit information.
10048        '''
10049        self.role = role if role is not None else None
10050        '''
10051         The requested Role.
10052        '''
10053
10054    def __repr__(self):
10055        return '<sdm.RoleGetResponse ' + \
10056            'meta: ' + repr(self.meta) + ' ' +\
10057            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10058            'role: ' + repr(self.role) + ' ' +\
10059            '>'
10060
10061    def to_dict(self):
10062        return {
10063            'meta': self.meta,
10064            'rate_limit': self.rate_limit,
10065            'role': self.role,
10066        }
10067
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073            role=d.get('role'),
10074        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10035    def __init__(
10036        self,
10037        meta=None,
10038        rate_limit=None,
10039        role=None,
10040    ):
10041        self.meta = meta if meta is not None else None
10042        '''
10043         Reserved for future use.
10044        '''
10045        self.rate_limit = rate_limit if rate_limit is not None else None
10046        '''
10047         Rate limit information.
10048        '''
10049        self.role = role if role is not None else None
10050        '''
10051         The requested Role.
10052        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10061    def to_dict(self):
10062        return {
10063            'meta': self.meta,
10064            'rate_limit': self.rate_limit,
10065            'role': self.role,
10066        }
@classmethod
def from_dict(cls, d)
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073            role=d.get('role'),
10074        )
class RoleUpdateResponse:
10077class RoleUpdateResponse:
10078    '''
10079         RoleUpdateResponse returns the fields of a Role after it has been updated by
10080     a RoleUpdateRequest.
10081    '''
10082    __slots__ = [
10083        'meta',
10084        'rate_limit',
10085        'role',
10086    ]
10087
10088    def __init__(
10089        self,
10090        meta=None,
10091        rate_limit=None,
10092        role=None,
10093    ):
10094        self.meta = meta if meta is not None else None
10095        '''
10096         Reserved for future use.
10097        '''
10098        self.rate_limit = rate_limit if rate_limit is not None else None
10099        '''
10100         Rate limit information.
10101        '''
10102        self.role = role if role is not None else None
10103        '''
10104         The updated Role.
10105        '''
10106
10107    def __repr__(self):
10108        return '<sdm.RoleUpdateResponse ' + \
10109            'meta: ' + repr(self.meta) + ' ' +\
10110            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10111            'role: ' + repr(self.role) + ' ' +\
10112            '>'
10113
10114    def to_dict(self):
10115        return {
10116            'meta': self.meta,
10117            'rate_limit': self.rate_limit,
10118            'role': self.role,
10119        }
10120
10121    @classmethod
10122    def from_dict(cls, d):
10123        return cls(
10124            meta=d.get('meta'),
10125            rate_limit=d.get('rate_limit'),
10126            role=d.get('role'),
10127        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10088    def __init__(
10089        self,
10090        meta=None,
10091        rate_limit=None,
10092        role=None,
10093    ):
10094        self.meta = meta if meta is not None else None
10095        '''
10096         Reserved for future use.
10097        '''
10098        self.rate_limit = rate_limit if rate_limit is not None else None
10099        '''
10100         Rate limit information.
10101        '''
10102        self.role = role if role is not None else None
10103        '''
10104         The updated Role.
10105        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10114    def to_dict(self):
10115        return {
10116            'meta': self.meta,
10117            'rate_limit': self.rate_limit,
10118            'role': self.role,
10119        }
@classmethod
def from_dict(cls, d)
10121    @classmethod
10122    def from_dict(cls, d):
10123        return cls(
10124            meta=d.get('meta'),
10125            rate_limit=d.get('rate_limit'),
10126            role=d.get('role'),
10127        )
class SQLServer:
10130class SQLServer:
10131    __slots__ = [
10132        'bind_interface',
10133        'database',
10134        'egress_filter',
10135        'healthy',
10136        'hostname',
10137        'id',
10138        'name',
10139        'override_database',
10140        'password',
10141        'port',
10142        'port_override',
10143        'schema',
10144        'secret_store_id',
10145        'tags',
10146        'username',
10147    ]
10148
10149    def __init__(
10150        self,
10151        bind_interface=None,
10152        database=None,
10153        egress_filter=None,
10154        healthy=None,
10155        hostname=None,
10156        id=None,
10157        name=None,
10158        override_database=None,
10159        password=None,
10160        port=None,
10161        port_override=None,
10162        schema=None,
10163        secret_store_id=None,
10164        tags=None,
10165        username=None,
10166    ):
10167        self.bind_interface = bind_interface if bind_interface is not None else ''
10168        '''
10169         Bind interface
10170        '''
10171        self.database = database if database is not None else ''
10172        self.egress_filter = egress_filter if egress_filter is not None else ''
10173        '''
10174         A filter applied to the routing logic to pin datasource to nodes.
10175        '''
10176        self.healthy = healthy if healthy is not None else False
10177        '''
10178         True if the datasource is reachable and the credentials are valid.
10179        '''
10180        self.hostname = hostname if hostname is not None else ''
10181        self.id = id if id is not None else ''
10182        '''
10183         Unique identifier of the Resource.
10184        '''
10185        self.name = name if name is not None else ''
10186        '''
10187         Unique human-readable name of the Resource.
10188        '''
10189        self.override_database = override_database if override_database is not None else False
10190        self.password = password if password is not None else ''
10191        self.port = port if port is not None else 0
10192        self.port_override = port_override if port_override is not None else 0
10193        self.schema = schema if schema is not None else ''
10194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10195        '''
10196         ID of the secret store containing credentials for this resource, if any.
10197        '''
10198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10199        '''
10200         Tags is a map of key, value pairs.
10201        '''
10202        self.username = username if username is not None else ''
10203
10204    def __repr__(self):
10205        return '<sdm.SQLServer ' + \
10206            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10207            'database: ' + repr(self.database) + ' ' +\
10208            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10209            'healthy: ' + repr(self.healthy) + ' ' +\
10210            'hostname: ' + repr(self.hostname) + ' ' +\
10211            'id: ' + repr(self.id) + ' ' +\
10212            'name: ' + repr(self.name) + ' ' +\
10213            'override_database: ' + repr(self.override_database) + ' ' +\
10214            'password: ' + repr(self.password) + ' ' +\
10215            'port: ' + repr(self.port) + ' ' +\
10216            'port_override: ' + repr(self.port_override) + ' ' +\
10217            'schema: ' + repr(self.schema) + ' ' +\
10218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10219            'tags: ' + repr(self.tags) + ' ' +\
10220            'username: ' + repr(self.username) + ' ' +\
10221            '>'
10222
10223    def to_dict(self):
10224        return {
10225            'bind_interface': self.bind_interface,
10226            'database': self.database,
10227            'egress_filter': self.egress_filter,
10228            'healthy': self.healthy,
10229            'hostname': self.hostname,
10230            'id': self.id,
10231            'name': self.name,
10232            'override_database': self.override_database,
10233            'password': self.password,
10234            'port': self.port,
10235            'port_override': self.port_override,
10236            'schema': self.schema,
10237            'secret_store_id': self.secret_store_id,
10238            'tags': self.tags,
10239            'username': self.username,
10240        }
10241
10242    @classmethod
10243    def from_dict(cls, d):
10244        return cls(
10245            bind_interface=d.get('bind_interface'),
10246            database=d.get('database'),
10247            egress_filter=d.get('egress_filter'),
10248            healthy=d.get('healthy'),
10249            hostname=d.get('hostname'),
10250            id=d.get('id'),
10251            name=d.get('name'),
10252            override_database=d.get('override_database'),
10253            password=d.get('password'),
10254            port=d.get('port'),
10255            port_override=d.get('port_override'),
10256            schema=d.get('schema'),
10257            secret_store_id=d.get('secret_store_id'),
10258            tags=d.get('tags'),
10259            username=d.get('username'),
10260        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10149    def __init__(
10150        self,
10151        bind_interface=None,
10152        database=None,
10153        egress_filter=None,
10154        healthy=None,
10155        hostname=None,
10156        id=None,
10157        name=None,
10158        override_database=None,
10159        password=None,
10160        port=None,
10161        port_override=None,
10162        schema=None,
10163        secret_store_id=None,
10164        tags=None,
10165        username=None,
10166    ):
10167        self.bind_interface = bind_interface if bind_interface is not None else ''
10168        '''
10169         Bind interface
10170        '''
10171        self.database = database if database is not None else ''
10172        self.egress_filter = egress_filter if egress_filter is not None else ''
10173        '''
10174         A filter applied to the routing logic to pin datasource to nodes.
10175        '''
10176        self.healthy = healthy if healthy is not None else False
10177        '''
10178         True if the datasource is reachable and the credentials are valid.
10179        '''
10180        self.hostname = hostname if hostname is not None else ''
10181        self.id = id if id is not None else ''
10182        '''
10183         Unique identifier of the Resource.
10184        '''
10185        self.name = name if name is not None else ''
10186        '''
10187         Unique human-readable name of the Resource.
10188        '''
10189        self.override_database = override_database if override_database is not None else False
10190        self.password = password if password is not None else ''
10191        self.port = port if port is not None else 0
10192        self.port_override = port_override if port_override is not None else 0
10193        self.schema = schema if schema is not None else ''
10194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10195        '''
10196         ID of the secret store containing credentials for this resource, if any.
10197        '''
10198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10199        '''
10200         Tags is a map of key, value pairs.
10201        '''
10202        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10223    def to_dict(self):
10224        return {
10225            'bind_interface': self.bind_interface,
10226            'database': self.database,
10227            'egress_filter': self.egress_filter,
10228            'healthy': self.healthy,
10229            'hostname': self.hostname,
10230            'id': self.id,
10231            'name': self.name,
10232            'override_database': self.override_database,
10233            'password': self.password,
10234            'port': self.port,
10235            'port_override': self.port_override,
10236            'schema': self.schema,
10237            'secret_store_id': self.secret_store_id,
10238            'tags': self.tags,
10239            'username': self.username,
10240        }
@classmethod
def from_dict(cls, d)
10242    @classmethod
10243    def from_dict(cls, d):
10244        return cls(
10245            bind_interface=d.get('bind_interface'),
10246            database=d.get('database'),
10247            egress_filter=d.get('egress_filter'),
10248            healthy=d.get('healthy'),
10249            hostname=d.get('hostname'),
10250            id=d.get('id'),
10251            name=d.get('name'),
10252            override_database=d.get('override_database'),
10253            password=d.get('password'),
10254            port=d.get('port'),
10255            port_override=d.get('port_override'),
10256            schema=d.get('schema'),
10257            secret_store_id=d.get('secret_store_id'),
10258            tags=d.get('tags'),
10259            username=d.get('username'),
10260        )
class SSH:
10263class SSH:
10264    __slots__ = [
10265        'allow_deprecated_key_exchanges',
10266        'bind_interface',
10267        'egress_filter',
10268        'healthy',
10269        'hostname',
10270        'id',
10271        'key_type',
10272        'name',
10273        'port',
10274        'port_forwarding',
10275        'port_override',
10276        'public_key',
10277        'secret_store_id',
10278        'tags',
10279        'username',
10280    ]
10281
10282    def __init__(
10283        self,
10284        allow_deprecated_key_exchanges=None,
10285        bind_interface=None,
10286        egress_filter=None,
10287        healthy=None,
10288        hostname=None,
10289        id=None,
10290        key_type=None,
10291        name=None,
10292        port=None,
10293        port_forwarding=None,
10294        port_override=None,
10295        public_key=None,
10296        secret_store_id=None,
10297        tags=None,
10298        username=None,
10299    ):
10300        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10301        self.bind_interface = bind_interface if bind_interface is not None else ''
10302        '''
10303         Bind interface
10304        '''
10305        self.egress_filter = egress_filter if egress_filter is not None else ''
10306        '''
10307         A filter applied to the routing logic to pin datasource to nodes.
10308        '''
10309        self.healthy = healthy if healthy is not None else False
10310        '''
10311         True if the datasource is reachable and the credentials are valid.
10312        '''
10313        self.hostname = hostname if hostname is not None else ''
10314        self.id = id if id is not None else ''
10315        '''
10316         Unique identifier of the Resource.
10317        '''
10318        self.key_type = key_type if key_type is not None else ''
10319        self.name = name if name is not None else ''
10320        '''
10321         Unique human-readable name of the Resource.
10322        '''
10323        self.port = port if port is not None else 0
10324        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10325        self.port_override = port_override if port_override is not None else 0
10326        self.public_key = public_key if public_key is not None else ''
10327        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10328        '''
10329         ID of the secret store containing credentials for this resource, if any.
10330        '''
10331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10332        '''
10333         Tags is a map of key, value pairs.
10334        '''
10335        self.username = username if username is not None else ''
10336
10337    def __repr__(self):
10338        return '<sdm.SSH ' + \
10339            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10340            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10341            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10342            'healthy: ' + repr(self.healthy) + ' ' +\
10343            'hostname: ' + repr(self.hostname) + ' ' +\
10344            'id: ' + repr(self.id) + ' ' +\
10345            'key_type: ' + repr(self.key_type) + ' ' +\
10346            'name: ' + repr(self.name) + ' ' +\
10347            'port: ' + repr(self.port) + ' ' +\
10348            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10349            'port_override: ' + repr(self.port_override) + ' ' +\
10350            'public_key: ' + repr(self.public_key) + ' ' +\
10351            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10352            'tags: ' + repr(self.tags) + ' ' +\
10353            'username: ' + repr(self.username) + ' ' +\
10354            '>'
10355
10356    def to_dict(self):
10357        return {
10358            'allow_deprecated_key_exchanges':
10359            self.allow_deprecated_key_exchanges,
10360            'bind_interface': self.bind_interface,
10361            'egress_filter': self.egress_filter,
10362            'healthy': self.healthy,
10363            'hostname': self.hostname,
10364            'id': self.id,
10365            'key_type': self.key_type,
10366            'name': self.name,
10367            'port': self.port,
10368            'port_forwarding': self.port_forwarding,
10369            'port_override': self.port_override,
10370            'public_key': self.public_key,
10371            'secret_store_id': self.secret_store_id,
10372            'tags': self.tags,
10373            'username': self.username,
10374        }
10375
10376    @classmethod
10377    def from_dict(cls, d):
10378        return cls(
10379            allow_deprecated_key_exchanges=d.get(
10380                'allow_deprecated_key_exchanges'),
10381            bind_interface=d.get('bind_interface'),
10382            egress_filter=d.get('egress_filter'),
10383            healthy=d.get('healthy'),
10384            hostname=d.get('hostname'),
10385            id=d.get('id'),
10386            key_type=d.get('key_type'),
10387            name=d.get('name'),
10388            port=d.get('port'),
10389            port_forwarding=d.get('port_forwarding'),
10390            port_override=d.get('port_override'),
10391            public_key=d.get('public_key'),
10392            secret_store_id=d.get('secret_store_id'),
10393            tags=d.get('tags'),
10394            username=d.get('username'),
10395        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10282    def __init__(
10283        self,
10284        allow_deprecated_key_exchanges=None,
10285        bind_interface=None,
10286        egress_filter=None,
10287        healthy=None,
10288        hostname=None,
10289        id=None,
10290        key_type=None,
10291        name=None,
10292        port=None,
10293        port_forwarding=None,
10294        port_override=None,
10295        public_key=None,
10296        secret_store_id=None,
10297        tags=None,
10298        username=None,
10299    ):
10300        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10301        self.bind_interface = bind_interface if bind_interface is not None else ''
10302        '''
10303         Bind interface
10304        '''
10305        self.egress_filter = egress_filter if egress_filter is not None else ''
10306        '''
10307         A filter applied to the routing logic to pin datasource to nodes.
10308        '''
10309        self.healthy = healthy if healthy is not None else False
10310        '''
10311         True if the datasource is reachable and the credentials are valid.
10312        '''
10313        self.hostname = hostname if hostname is not None else ''
10314        self.id = id if id is not None else ''
10315        '''
10316         Unique identifier of the Resource.
10317        '''
10318        self.key_type = key_type if key_type is not None else ''
10319        self.name = name if name is not None else ''
10320        '''
10321         Unique human-readable name of the Resource.
10322        '''
10323        self.port = port if port is not None else 0
10324        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10325        self.port_override = port_override if port_override is not None else 0
10326        self.public_key = public_key if public_key is not None else ''
10327        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10328        '''
10329         ID of the secret store containing credentials for this resource, if any.
10330        '''
10331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10332        '''
10333         Tags is a map of key, value pairs.
10334        '''
10335        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10356    def to_dict(self):
10357        return {
10358            'allow_deprecated_key_exchanges':
10359            self.allow_deprecated_key_exchanges,
10360            'bind_interface': self.bind_interface,
10361            'egress_filter': self.egress_filter,
10362            'healthy': self.healthy,
10363            'hostname': self.hostname,
10364            'id': self.id,
10365            'key_type': self.key_type,
10366            'name': self.name,
10367            'port': self.port,
10368            'port_forwarding': self.port_forwarding,
10369            'port_override': self.port_override,
10370            'public_key': self.public_key,
10371            'secret_store_id': self.secret_store_id,
10372            'tags': self.tags,
10373            'username': self.username,
10374        }
@classmethod
def from_dict(cls, d)
10376    @classmethod
10377    def from_dict(cls, d):
10378        return cls(
10379            allow_deprecated_key_exchanges=d.get(
10380                'allow_deprecated_key_exchanges'),
10381            bind_interface=d.get('bind_interface'),
10382            egress_filter=d.get('egress_filter'),
10383            healthy=d.get('healthy'),
10384            hostname=d.get('hostname'),
10385            id=d.get('id'),
10386            key_type=d.get('key_type'),
10387            name=d.get('name'),
10388            port=d.get('port'),
10389            port_forwarding=d.get('port_forwarding'),
10390            port_override=d.get('port_override'),
10391            public_key=d.get('public_key'),
10392            secret_store_id=d.get('secret_store_id'),
10393            tags=d.get('tags'),
10394            username=d.get('username'),
10395        )
class SSHCert:
10398class SSHCert:
10399    __slots__ = [
10400        'allow_deprecated_key_exchanges',
10401        'bind_interface',
10402        'egress_filter',
10403        'healthy',
10404        'hostname',
10405        'id',
10406        'key_type',
10407        'name',
10408        'port',
10409        'port_forwarding',
10410        'port_override',
10411        'remote_identity_group_id',
10412        'remote_identity_healthcheck_username',
10413        'secret_store_id',
10414        'tags',
10415        'username',
10416    ]
10417
10418    def __init__(
10419        self,
10420        allow_deprecated_key_exchanges=None,
10421        bind_interface=None,
10422        egress_filter=None,
10423        healthy=None,
10424        hostname=None,
10425        id=None,
10426        key_type=None,
10427        name=None,
10428        port=None,
10429        port_forwarding=None,
10430        port_override=None,
10431        remote_identity_group_id=None,
10432        remote_identity_healthcheck_username=None,
10433        secret_store_id=None,
10434        tags=None,
10435        username=None,
10436    ):
10437        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10438        self.bind_interface = bind_interface if bind_interface is not None else ''
10439        '''
10440         Bind interface
10441        '''
10442        self.egress_filter = egress_filter if egress_filter is not None else ''
10443        '''
10444         A filter applied to the routing logic to pin datasource to nodes.
10445        '''
10446        self.healthy = healthy if healthy is not None else False
10447        '''
10448         True if the datasource is reachable and the credentials are valid.
10449        '''
10450        self.hostname = hostname if hostname is not None else ''
10451        self.id = id if id is not None else ''
10452        '''
10453         Unique identifier of the Resource.
10454        '''
10455        self.key_type = key_type if key_type is not None else ''
10456        self.name = name if name is not None else ''
10457        '''
10458         Unique human-readable name of the Resource.
10459        '''
10460        self.port = port if port is not None else 0
10461        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10462        self.port_override = port_override if port_override is not None else 0
10463        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10464        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10465        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10466        '''
10467         ID of the secret store containing credentials for this resource, if any.
10468        '''
10469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10470        '''
10471         Tags is a map of key, value pairs.
10472        '''
10473        self.username = username if username is not None else ''
10474
10475    def __repr__(self):
10476        return '<sdm.SSHCert ' + \
10477            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10478            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10479            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10480            'healthy: ' + repr(self.healthy) + ' ' +\
10481            'hostname: ' + repr(self.hostname) + ' ' +\
10482            'id: ' + repr(self.id) + ' ' +\
10483            'key_type: ' + repr(self.key_type) + ' ' +\
10484            'name: ' + repr(self.name) + ' ' +\
10485            'port: ' + repr(self.port) + ' ' +\
10486            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10487            'port_override: ' + repr(self.port_override) + ' ' +\
10488            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10489            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10490            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10491            'tags: ' + repr(self.tags) + ' ' +\
10492            'username: ' + repr(self.username) + ' ' +\
10493            '>'
10494
10495    def to_dict(self):
10496        return {
10497            'allow_deprecated_key_exchanges':
10498            self.allow_deprecated_key_exchanges,
10499            'bind_interface': self.bind_interface,
10500            'egress_filter': self.egress_filter,
10501            'healthy': self.healthy,
10502            'hostname': self.hostname,
10503            'id': self.id,
10504            'key_type': self.key_type,
10505            'name': self.name,
10506            'port': self.port,
10507            'port_forwarding': self.port_forwarding,
10508            'port_override': self.port_override,
10509            'remote_identity_group_id': self.remote_identity_group_id,
10510            'remote_identity_healthcheck_username':
10511            self.remote_identity_healthcheck_username,
10512            'secret_store_id': self.secret_store_id,
10513            'tags': self.tags,
10514            'username': self.username,
10515        }
10516
10517    @classmethod
10518    def from_dict(cls, d):
10519        return cls(
10520            allow_deprecated_key_exchanges=d.get(
10521                'allow_deprecated_key_exchanges'),
10522            bind_interface=d.get('bind_interface'),
10523            egress_filter=d.get('egress_filter'),
10524            healthy=d.get('healthy'),
10525            hostname=d.get('hostname'),
10526            id=d.get('id'),
10527            key_type=d.get('key_type'),
10528            name=d.get('name'),
10529            port=d.get('port'),
10530            port_forwarding=d.get('port_forwarding'),
10531            port_override=d.get('port_override'),
10532            remote_identity_group_id=d.get('remote_identity_group_id'),
10533            remote_identity_healthcheck_username=d.get(
10534                'remote_identity_healthcheck_username'),
10535            secret_store_id=d.get('secret_store_id'),
10536            tags=d.get('tags'),
10537            username=d.get('username'),
10538        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10418    def __init__(
10419        self,
10420        allow_deprecated_key_exchanges=None,
10421        bind_interface=None,
10422        egress_filter=None,
10423        healthy=None,
10424        hostname=None,
10425        id=None,
10426        key_type=None,
10427        name=None,
10428        port=None,
10429        port_forwarding=None,
10430        port_override=None,
10431        remote_identity_group_id=None,
10432        remote_identity_healthcheck_username=None,
10433        secret_store_id=None,
10434        tags=None,
10435        username=None,
10436    ):
10437        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10438        self.bind_interface = bind_interface if bind_interface is not None else ''
10439        '''
10440         Bind interface
10441        '''
10442        self.egress_filter = egress_filter if egress_filter is not None else ''
10443        '''
10444         A filter applied to the routing logic to pin datasource to nodes.
10445        '''
10446        self.healthy = healthy if healthy is not None else False
10447        '''
10448         True if the datasource is reachable and the credentials are valid.
10449        '''
10450        self.hostname = hostname if hostname is not None else ''
10451        self.id = id if id is not None else ''
10452        '''
10453         Unique identifier of the Resource.
10454        '''
10455        self.key_type = key_type if key_type is not None else ''
10456        self.name = name if name is not None else ''
10457        '''
10458         Unique human-readable name of the Resource.
10459        '''
10460        self.port = port if port is not None else 0
10461        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10462        self.port_override = port_override if port_override is not None else 0
10463        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10464        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10465        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10466        '''
10467         ID of the secret store containing credentials for this resource, if any.
10468        '''
10469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10470        '''
10471         Tags is a map of key, value pairs.
10472        '''
10473        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10495    def to_dict(self):
10496        return {
10497            'allow_deprecated_key_exchanges':
10498            self.allow_deprecated_key_exchanges,
10499            'bind_interface': self.bind_interface,
10500            'egress_filter': self.egress_filter,
10501            'healthy': self.healthy,
10502            'hostname': self.hostname,
10503            'id': self.id,
10504            'key_type': self.key_type,
10505            'name': self.name,
10506            'port': self.port,
10507            'port_forwarding': self.port_forwarding,
10508            'port_override': self.port_override,
10509            'remote_identity_group_id': self.remote_identity_group_id,
10510            'remote_identity_healthcheck_username':
10511            self.remote_identity_healthcheck_username,
10512            'secret_store_id': self.secret_store_id,
10513            'tags': self.tags,
10514            'username': self.username,
10515        }
@classmethod
def from_dict(cls, d)
10517    @classmethod
10518    def from_dict(cls, d):
10519        return cls(
10520            allow_deprecated_key_exchanges=d.get(
10521                'allow_deprecated_key_exchanges'),
10522            bind_interface=d.get('bind_interface'),
10523            egress_filter=d.get('egress_filter'),
10524            healthy=d.get('healthy'),
10525            hostname=d.get('hostname'),
10526            id=d.get('id'),
10527            key_type=d.get('key_type'),
10528            name=d.get('name'),
10529            port=d.get('port'),
10530            port_forwarding=d.get('port_forwarding'),
10531            port_override=d.get('port_override'),
10532            remote_identity_group_id=d.get('remote_identity_group_id'),
10533            remote_identity_healthcheck_username=d.get(
10534                'remote_identity_healthcheck_username'),
10535            secret_store_id=d.get('secret_store_id'),
10536            tags=d.get('tags'),
10537            username=d.get('username'),
10538        )
class SSHCustomerKey:
10541class SSHCustomerKey:
10542    __slots__ = [
10543        'allow_deprecated_key_exchanges',
10544        'bind_interface',
10545        'egress_filter',
10546        'healthy',
10547        'hostname',
10548        'id',
10549        'name',
10550        'port',
10551        'port_forwarding',
10552        'port_override',
10553        'private_key',
10554        'secret_store_id',
10555        'tags',
10556        'username',
10557    ]
10558
10559    def __init__(
10560        self,
10561        allow_deprecated_key_exchanges=None,
10562        bind_interface=None,
10563        egress_filter=None,
10564        healthy=None,
10565        hostname=None,
10566        id=None,
10567        name=None,
10568        port=None,
10569        port_forwarding=None,
10570        port_override=None,
10571        private_key=None,
10572        secret_store_id=None,
10573        tags=None,
10574        username=None,
10575    ):
10576        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10577        self.bind_interface = bind_interface if bind_interface is not None else ''
10578        '''
10579         Bind interface
10580        '''
10581        self.egress_filter = egress_filter if egress_filter is not None else ''
10582        '''
10583         A filter applied to the routing logic to pin datasource to nodes.
10584        '''
10585        self.healthy = healthy if healthy is not None else False
10586        '''
10587         True if the datasource is reachable and the credentials are valid.
10588        '''
10589        self.hostname = hostname if hostname is not None else ''
10590        self.id = id if id is not None else ''
10591        '''
10592         Unique identifier of the Resource.
10593        '''
10594        self.name = name if name is not None else ''
10595        '''
10596         Unique human-readable name of the Resource.
10597        '''
10598        self.port = port if port is not None else 0
10599        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10600        self.port_override = port_override if port_override is not None else 0
10601        self.private_key = private_key if private_key is not None else ''
10602        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10603        '''
10604         ID of the secret store containing credentials for this resource, if any.
10605        '''
10606        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10607        '''
10608         Tags is a map of key, value pairs.
10609        '''
10610        self.username = username if username is not None else ''
10611
10612    def __repr__(self):
10613        return '<sdm.SSHCustomerKey ' + \
10614            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10616            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10617            'healthy: ' + repr(self.healthy) + ' ' +\
10618            'hostname: ' + repr(self.hostname) + ' ' +\
10619            'id: ' + repr(self.id) + ' ' +\
10620            'name: ' + repr(self.name) + ' ' +\
10621            'port: ' + repr(self.port) + ' ' +\
10622            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10623            'port_override: ' + repr(self.port_override) + ' ' +\
10624            'private_key: ' + repr(self.private_key) + ' ' +\
10625            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10626            'tags: ' + repr(self.tags) + ' ' +\
10627            'username: ' + repr(self.username) + ' ' +\
10628            '>'
10629
10630    def to_dict(self):
10631        return {
10632            'allow_deprecated_key_exchanges':
10633            self.allow_deprecated_key_exchanges,
10634            'bind_interface': self.bind_interface,
10635            'egress_filter': self.egress_filter,
10636            'healthy': self.healthy,
10637            'hostname': self.hostname,
10638            'id': self.id,
10639            'name': self.name,
10640            'port': self.port,
10641            'port_forwarding': self.port_forwarding,
10642            'port_override': self.port_override,
10643            'private_key': self.private_key,
10644            'secret_store_id': self.secret_store_id,
10645            'tags': self.tags,
10646            'username': self.username,
10647        }
10648
10649    @classmethod
10650    def from_dict(cls, d):
10651        return cls(
10652            allow_deprecated_key_exchanges=d.get(
10653                'allow_deprecated_key_exchanges'),
10654            bind_interface=d.get('bind_interface'),
10655            egress_filter=d.get('egress_filter'),
10656            healthy=d.get('healthy'),
10657            hostname=d.get('hostname'),
10658            id=d.get('id'),
10659            name=d.get('name'),
10660            port=d.get('port'),
10661            port_forwarding=d.get('port_forwarding'),
10662            port_override=d.get('port_override'),
10663            private_key=d.get('private_key'),
10664            secret_store_id=d.get('secret_store_id'),
10665            tags=d.get('tags'),
10666            username=d.get('username'),
10667        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
10559    def __init__(
10560        self,
10561        allow_deprecated_key_exchanges=None,
10562        bind_interface=None,
10563        egress_filter=None,
10564        healthy=None,
10565        hostname=None,
10566        id=None,
10567        name=None,
10568        port=None,
10569        port_forwarding=None,
10570        port_override=None,
10571        private_key=None,
10572        secret_store_id=None,
10573        tags=None,
10574        username=None,
10575    ):
10576        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10577        self.bind_interface = bind_interface if bind_interface is not None else ''
10578        '''
10579         Bind interface
10580        '''
10581        self.egress_filter = egress_filter if egress_filter is not None else ''
10582        '''
10583         A filter applied to the routing logic to pin datasource to nodes.
10584        '''
10585        self.healthy = healthy if healthy is not None else False
10586        '''
10587         True if the datasource is reachable and the credentials are valid.
10588        '''
10589        self.hostname = hostname if hostname is not None else ''
10590        self.id = id if id is not None else ''
10591        '''
10592         Unique identifier of the Resource.
10593        '''
10594        self.name = name if name is not None else ''
10595        '''
10596         Unique human-readable name of the Resource.
10597        '''
10598        self.port = port if port is not None else 0
10599        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10600        self.port_override = port_override if port_override is not None else 0
10601        self.private_key = private_key if private_key is not None else ''
10602        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10603        '''
10604         ID of the secret store containing credentials for this resource, if any.
10605        '''
10606        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10607        '''
10608         Tags is a map of key, value pairs.
10609        '''
10610        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10630    def to_dict(self):
10631        return {
10632            'allow_deprecated_key_exchanges':
10633            self.allow_deprecated_key_exchanges,
10634            'bind_interface': self.bind_interface,
10635            'egress_filter': self.egress_filter,
10636            'healthy': self.healthy,
10637            'hostname': self.hostname,
10638            'id': self.id,
10639            'name': self.name,
10640            'port': self.port,
10641            'port_forwarding': self.port_forwarding,
10642            'port_override': self.port_override,
10643            'private_key': self.private_key,
10644            'secret_store_id': self.secret_store_id,
10645            'tags': self.tags,
10646            'username': self.username,
10647        }
@classmethod
def from_dict(cls, d)
10649    @classmethod
10650    def from_dict(cls, d):
10651        return cls(
10652            allow_deprecated_key_exchanges=d.get(
10653                'allow_deprecated_key_exchanges'),
10654            bind_interface=d.get('bind_interface'),
10655            egress_filter=d.get('egress_filter'),
10656            healthy=d.get('healthy'),
10657            hostname=d.get('hostname'),
10658            id=d.get('id'),
10659            name=d.get('name'),
10660            port=d.get('port'),
10661            port_forwarding=d.get('port_forwarding'),
10662            port_override=d.get('port_override'),
10663            private_key=d.get('private_key'),
10664            secret_store_id=d.get('secret_store_id'),
10665            tags=d.get('tags'),
10666            username=d.get('username'),
10667        )
class SecretStoreCreateResponse:
10670class SecretStoreCreateResponse:
10671    '''
10672         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10673    '''
10674    __slots__ = [
10675        'meta',
10676        'rate_limit',
10677        'secret_store',
10678    ]
10679
10680    def __init__(
10681        self,
10682        meta=None,
10683        rate_limit=None,
10684        secret_store=None,
10685    ):
10686        self.meta = meta if meta is not None else None
10687        '''
10688         Reserved for future use.
10689        '''
10690        self.rate_limit = rate_limit if rate_limit is not None else None
10691        '''
10692         Rate limit information.
10693        '''
10694        self.secret_store = secret_store if secret_store is not None else None
10695        '''
10696         The created SecretStore.
10697        '''
10698
10699    def __repr__(self):
10700        return '<sdm.SecretStoreCreateResponse ' + \
10701            'meta: ' + repr(self.meta) + ' ' +\
10702            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10703            'secret_store: ' + repr(self.secret_store) + ' ' +\
10704            '>'
10705
10706    def to_dict(self):
10707        return {
10708            'meta': self.meta,
10709            'rate_limit': self.rate_limit,
10710            'secret_store': self.secret_store,
10711        }
10712
10713    @classmethod
10714    def from_dict(cls, d):
10715        return cls(
10716            meta=d.get('meta'),
10717            rate_limit=d.get('rate_limit'),
10718            secret_store=d.get('secret_store'),
10719        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
10680    def __init__(
10681        self,
10682        meta=None,
10683        rate_limit=None,
10684        secret_store=None,
10685    ):
10686        self.meta = meta if meta is not None else None
10687        '''
10688         Reserved for future use.
10689        '''
10690        self.rate_limit = rate_limit if rate_limit is not None else None
10691        '''
10692         Rate limit information.
10693        '''
10694        self.secret_store = secret_store if secret_store is not None else None
10695        '''
10696         The created SecretStore.
10697        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
10706    def to_dict(self):
10707        return {
10708            'meta': self.meta,
10709            'rate_limit': self.rate_limit,
10710            'secret_store': self.secret_store,
10711        }
@classmethod
def from_dict(cls, d)
10713    @classmethod
10714    def from_dict(cls, d):
10715        return cls(
10716            meta=d.get('meta'),
10717            rate_limit=d.get('rate_limit'),
10718            secret_store=d.get('secret_store'),
10719        )
class SecretStoreDeleteResponse:
10722class SecretStoreDeleteResponse:
10723    '''
10724         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
10725    '''
10726    __slots__ = [
10727        'meta',
10728        'rate_limit',
10729    ]
10730
10731    def __init__(
10732        self,
10733        meta=None,
10734        rate_limit=None,
10735    ):
10736        self.meta = meta if meta is not None else None
10737        '''
10738         Reserved for future use.
10739        '''
10740        self.rate_limit = rate_limit if rate_limit is not None else None
10741        '''
10742         Rate limit information.
10743        '''
10744
10745    def __repr__(self):
10746        return '<sdm.SecretStoreDeleteResponse ' + \
10747            'meta: ' + repr(self.meta) + ' ' +\
10748            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10749            '>'
10750
10751    def to_dict(self):
10752        return {
10753            'meta': self.meta,
10754            'rate_limit': self.rate_limit,
10755        }
10756
10757    @classmethod
10758    def from_dict(cls, d):
10759        return cls(
10760            meta=d.get('meta'),
10761            rate_limit=d.get('rate_limit'),
10762        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
10731    def __init__(
10732        self,
10733        meta=None,
10734        rate_limit=None,
10735    ):
10736        self.meta = meta if meta is not None else None
10737        '''
10738         Reserved for future use.
10739        '''
10740        self.rate_limit = rate_limit if rate_limit is not None else None
10741        '''
10742         Rate limit information.
10743        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10751    def to_dict(self):
10752        return {
10753            'meta': self.meta,
10754            'rate_limit': self.rate_limit,
10755        }
@classmethod
def from_dict(cls, d)
10757    @classmethod
10758    def from_dict(cls, d):
10759        return cls(
10760            meta=d.get('meta'),
10761            rate_limit=d.get('rate_limit'),
10762        )
class SecretStoreGetResponse:
10765class SecretStoreGetResponse:
10766    '''
10767         SecretStoreGetResponse returns a requested SecretStore.
10768    '''
10769    __slots__ = [
10770        'meta',
10771        'rate_limit',
10772        'secret_store',
10773    ]
10774
10775    def __init__(
10776        self,
10777        meta=None,
10778        rate_limit=None,
10779        secret_store=None,
10780    ):
10781        self.meta = meta if meta is not None else None
10782        '''
10783         Reserved for future use.
10784        '''
10785        self.rate_limit = rate_limit if rate_limit is not None else None
10786        '''
10787         Rate limit information.
10788        '''
10789        self.secret_store = secret_store if secret_store is not None else None
10790        '''
10791         The requested SecretStore.
10792        '''
10793
10794    def __repr__(self):
10795        return '<sdm.SecretStoreGetResponse ' + \
10796            'meta: ' + repr(self.meta) + ' ' +\
10797            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10798            'secret_store: ' + repr(self.secret_store) + ' ' +\
10799            '>'
10800
10801    def to_dict(self):
10802        return {
10803            'meta': self.meta,
10804            'rate_limit': self.rate_limit,
10805            'secret_store': self.secret_store,
10806        }
10807
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813            secret_store=d.get('secret_store'),
10814        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
10775    def __init__(
10776        self,
10777        meta=None,
10778        rate_limit=None,
10779        secret_store=None,
10780    ):
10781        self.meta = meta if meta is not None else None
10782        '''
10783         Reserved for future use.
10784        '''
10785        self.rate_limit = rate_limit if rate_limit is not None else None
10786        '''
10787         Rate limit information.
10788        '''
10789        self.secret_store = secret_store if secret_store is not None else None
10790        '''
10791         The requested SecretStore.
10792        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
10801    def to_dict(self):
10802        return {
10803            'meta': self.meta,
10804            'rate_limit': self.rate_limit,
10805            'secret_store': self.secret_store,
10806        }
@classmethod
def from_dict(cls, d)
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813            secret_store=d.get('secret_store'),
10814        )
class SecretStoreUpdateResponse:
10817class SecretStoreUpdateResponse:
10818    '''
10819         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
10820     a SecretStoreUpdateRequest.
10821    '''
10822    __slots__ = [
10823        'meta',
10824        'rate_limit',
10825        'secret_store',
10826    ]
10827
10828    def __init__(
10829        self,
10830        meta=None,
10831        rate_limit=None,
10832        secret_store=None,
10833    ):
10834        self.meta = meta if meta is not None else None
10835        '''
10836         Reserved for future use.
10837        '''
10838        self.rate_limit = rate_limit if rate_limit is not None else None
10839        '''
10840         Rate limit information.
10841        '''
10842        self.secret_store = secret_store if secret_store is not None else None
10843        '''
10844         The updated SecretStore.
10845        '''
10846
10847    def __repr__(self):
10848        return '<sdm.SecretStoreUpdateResponse ' + \
10849            'meta: ' + repr(self.meta) + ' ' +\
10850            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10851            'secret_store: ' + repr(self.secret_store) + ' ' +\
10852            '>'
10853
10854    def to_dict(self):
10855        return {
10856            'meta': self.meta,
10857            'rate_limit': self.rate_limit,
10858            'secret_store': self.secret_store,
10859        }
10860
10861    @classmethod
10862    def from_dict(cls, d):
10863        return cls(
10864            meta=d.get('meta'),
10865            rate_limit=d.get('rate_limit'),
10866            secret_store=d.get('secret_store'),
10867        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
10828    def __init__(
10829        self,
10830        meta=None,
10831        rate_limit=None,
10832        secret_store=None,
10833    ):
10834        self.meta = meta if meta is not None else None
10835        '''
10836         Reserved for future use.
10837        '''
10838        self.rate_limit = rate_limit if rate_limit is not None else None
10839        '''
10840         Rate limit information.
10841        '''
10842        self.secret_store = secret_store if secret_store is not None else None
10843        '''
10844         The updated SecretStore.
10845        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
10854    def to_dict(self):
10855        return {
10856            'meta': self.meta,
10857            'rate_limit': self.rate_limit,
10858            'secret_store': self.secret_store,
10859        }
@classmethod
def from_dict(cls, d)
10861    @classmethod
10862    def from_dict(cls, d):
10863        return cls(
10864            meta=d.get('meta'),
10865            rate_limit=d.get('rate_limit'),
10866            secret_store=d.get('secret_store'),
10867        )
class Service:
10870class Service:
10871    '''
10872         A Service is a service account that can connect to resources they are granted
10873     directly, or granted via roles. Services are typically automated jobs.
10874    '''
10875    __slots__ = [
10876        'id',
10877        'name',
10878        'suspended',
10879        'tags',
10880    ]
10881
10882    def __init__(
10883        self,
10884        id=None,
10885        name=None,
10886        suspended=None,
10887        tags=None,
10888    ):
10889        self.id = id if id is not None else ''
10890        '''
10891         Unique identifier of the Service.
10892        '''
10893        self.name = name if name is not None else ''
10894        '''
10895         Unique human-readable name of the Service.
10896        '''
10897        self.suspended = suspended if suspended is not None else False
10898        '''
10899         The Service's suspended state.
10900        '''
10901        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10902        '''
10903         Tags is a map of key, value pairs.
10904        '''
10905
10906    def __repr__(self):
10907        return '<sdm.Service ' + \
10908            'id: ' + repr(self.id) + ' ' +\
10909            'name: ' + repr(self.name) + ' ' +\
10910            'suspended: ' + repr(self.suspended) + ' ' +\
10911            'tags: ' + repr(self.tags) + ' ' +\
10912            '>'
10913
10914    def to_dict(self):
10915        return {
10916            'id': self.id,
10917            'name': self.name,
10918            'suspended': self.suspended,
10919            'tags': self.tags,
10920        }
10921
10922    @classmethod
10923    def from_dict(cls, d):
10924        return cls(
10925            id=d.get('id'),
10926            name=d.get('name'),
10927            suspended=d.get('suspended'),
10928            tags=d.get('tags'),
10929        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
10882    def __init__(
10883        self,
10884        id=None,
10885        name=None,
10886        suspended=None,
10887        tags=None,
10888    ):
10889        self.id = id if id is not None else ''
10890        '''
10891         Unique identifier of the Service.
10892        '''
10893        self.name = name if name is not None else ''
10894        '''
10895         Unique human-readable name of the Service.
10896        '''
10897        self.suspended = suspended if suspended is not None else False
10898        '''
10899         The Service's suspended state.
10900        '''
10901        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10902        '''
10903         Tags is a map of key, value pairs.
10904        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10914    def to_dict(self):
10915        return {
10916            'id': self.id,
10917            'name': self.name,
10918            'suspended': self.suspended,
10919            'tags': self.tags,
10920        }
@classmethod
def from_dict(cls, d)
10922    @classmethod
10923    def from_dict(cls, d):
10924        return cls(
10925            id=d.get('id'),
10926            name=d.get('name'),
10927            suspended=d.get('suspended'),
10928            tags=d.get('tags'),
10929        )
class SingleStore:
10932class SingleStore:
10933    __slots__ = [
10934        'bind_interface',
10935        'database',
10936        'egress_filter',
10937        'healthy',
10938        'hostname',
10939        'id',
10940        'name',
10941        'password',
10942        'port',
10943        'port_override',
10944        'secret_store_id',
10945        'tags',
10946        'username',
10947    ]
10948
10949    def __init__(
10950        self,
10951        bind_interface=None,
10952        database=None,
10953        egress_filter=None,
10954        healthy=None,
10955        hostname=None,
10956        id=None,
10957        name=None,
10958        password=None,
10959        port=None,
10960        port_override=None,
10961        secret_store_id=None,
10962        tags=None,
10963        username=None,
10964    ):
10965        self.bind_interface = bind_interface if bind_interface is not None else ''
10966        '''
10967         Bind interface
10968        '''
10969        self.database = database if database is not None else ''
10970        self.egress_filter = egress_filter if egress_filter is not None else ''
10971        '''
10972         A filter applied to the routing logic to pin datasource to nodes.
10973        '''
10974        self.healthy = healthy if healthy is not None else False
10975        '''
10976         True if the datasource is reachable and the credentials are valid.
10977        '''
10978        self.hostname = hostname if hostname is not None else ''
10979        self.id = id if id is not None else ''
10980        '''
10981         Unique identifier of the Resource.
10982        '''
10983        self.name = name if name is not None else ''
10984        '''
10985         Unique human-readable name of the Resource.
10986        '''
10987        self.password = password if password is not None else ''
10988        self.port = port if port is not None else 0
10989        self.port_override = port_override if port_override is not None else 0
10990        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10991        '''
10992         ID of the secret store containing credentials for this resource, if any.
10993        '''
10994        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10995        '''
10996         Tags is a map of key, value pairs.
10997        '''
10998        self.username = username if username is not None else ''
10999
11000    def __repr__(self):
11001        return '<sdm.SingleStore ' + \
11002            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11003            'database: ' + repr(self.database) + ' ' +\
11004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11005            'healthy: ' + repr(self.healthy) + ' ' +\
11006            'hostname: ' + repr(self.hostname) + ' ' +\
11007            'id: ' + repr(self.id) + ' ' +\
11008            'name: ' + repr(self.name) + ' ' +\
11009            'password: ' + repr(self.password) + ' ' +\
11010            'port: ' + repr(self.port) + ' ' +\
11011            'port_override: ' + repr(self.port_override) + ' ' +\
11012            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11013            'tags: ' + repr(self.tags) + ' ' +\
11014            'username: ' + repr(self.username) + ' ' +\
11015            '>'
11016
11017    def to_dict(self):
11018        return {
11019            'bind_interface': self.bind_interface,
11020            'database': self.database,
11021            'egress_filter': self.egress_filter,
11022            'healthy': self.healthy,
11023            'hostname': self.hostname,
11024            'id': self.id,
11025            'name': self.name,
11026            'password': self.password,
11027            'port': self.port,
11028            'port_override': self.port_override,
11029            'secret_store_id': self.secret_store_id,
11030            'tags': self.tags,
11031            'username': self.username,
11032        }
11033
11034    @classmethod
11035    def from_dict(cls, d):
11036        return cls(
11037            bind_interface=d.get('bind_interface'),
11038            database=d.get('database'),
11039            egress_filter=d.get('egress_filter'),
11040            healthy=d.get('healthy'),
11041            hostname=d.get('hostname'),
11042            id=d.get('id'),
11043            name=d.get('name'),
11044            password=d.get('password'),
11045            port=d.get('port'),
11046            port_override=d.get('port_override'),
11047            secret_store_id=d.get('secret_store_id'),
11048            tags=d.get('tags'),
11049            username=d.get('username'),
11050        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
10949    def __init__(
10950        self,
10951        bind_interface=None,
10952        database=None,
10953        egress_filter=None,
10954        healthy=None,
10955        hostname=None,
10956        id=None,
10957        name=None,
10958        password=None,
10959        port=None,
10960        port_override=None,
10961        secret_store_id=None,
10962        tags=None,
10963        username=None,
10964    ):
10965        self.bind_interface = bind_interface if bind_interface is not None else ''
10966        '''
10967         Bind interface
10968        '''
10969        self.database = database if database is not None else ''
10970        self.egress_filter = egress_filter if egress_filter is not None else ''
10971        '''
10972         A filter applied to the routing logic to pin datasource to nodes.
10973        '''
10974        self.healthy = healthy if healthy is not None else False
10975        '''
10976         True if the datasource is reachable and the credentials are valid.
10977        '''
10978        self.hostname = hostname if hostname is not None else ''
10979        self.id = id if id is not None else ''
10980        '''
10981         Unique identifier of the Resource.
10982        '''
10983        self.name = name if name is not None else ''
10984        '''
10985         Unique human-readable name of the Resource.
10986        '''
10987        self.password = password if password is not None else ''
10988        self.port = port if port is not None else 0
10989        self.port_override = port_override if port_override is not None else 0
10990        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10991        '''
10992         ID of the secret store containing credentials for this resource, if any.
10993        '''
10994        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10995        '''
10996         Tags is a map of key, value pairs.
10997        '''
10998        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11017    def to_dict(self):
11018        return {
11019            'bind_interface': self.bind_interface,
11020            'database': self.database,
11021            'egress_filter': self.egress_filter,
11022            'healthy': self.healthy,
11023            'hostname': self.hostname,
11024            'id': self.id,
11025            'name': self.name,
11026            'password': self.password,
11027            'port': self.port,
11028            'port_override': self.port_override,
11029            'secret_store_id': self.secret_store_id,
11030            'tags': self.tags,
11031            'username': self.username,
11032        }
@classmethod
def from_dict(cls, d)
11034    @classmethod
11035    def from_dict(cls, d):
11036        return cls(
11037            bind_interface=d.get('bind_interface'),
11038            database=d.get('database'),
11039            egress_filter=d.get('egress_filter'),
11040            healthy=d.get('healthy'),
11041            hostname=d.get('hostname'),
11042            id=d.get('id'),
11043            name=d.get('name'),
11044            password=d.get('password'),
11045            port=d.get('port'),
11046            port_override=d.get('port_override'),
11047            secret_store_id=d.get('secret_store_id'),
11048            tags=d.get('tags'),
11049            username=d.get('username'),
11050        )
class Snowflake:
11053class Snowflake:
11054    __slots__ = [
11055        'bind_interface',
11056        'database',
11057        'egress_filter',
11058        'healthy',
11059        'hostname',
11060        'id',
11061        'name',
11062        'password',
11063        'port_override',
11064        'schema',
11065        'secret_store_id',
11066        'tags',
11067        'username',
11068    ]
11069
11070    def __init__(
11071        self,
11072        bind_interface=None,
11073        database=None,
11074        egress_filter=None,
11075        healthy=None,
11076        hostname=None,
11077        id=None,
11078        name=None,
11079        password=None,
11080        port_override=None,
11081        schema=None,
11082        secret_store_id=None,
11083        tags=None,
11084        username=None,
11085    ):
11086        self.bind_interface = bind_interface if bind_interface is not None else ''
11087        '''
11088         Bind interface
11089        '''
11090        self.database = database if database is not None else ''
11091        self.egress_filter = egress_filter if egress_filter is not None else ''
11092        '''
11093         A filter applied to the routing logic to pin datasource to nodes.
11094        '''
11095        self.healthy = healthy if healthy is not None else False
11096        '''
11097         True if the datasource is reachable and the credentials are valid.
11098        '''
11099        self.hostname = hostname if hostname is not None else ''
11100        self.id = id if id is not None else ''
11101        '''
11102         Unique identifier of the Resource.
11103        '''
11104        self.name = name if name is not None else ''
11105        '''
11106         Unique human-readable name of the Resource.
11107        '''
11108        self.password = password if password is not None else ''
11109        self.port_override = port_override if port_override is not None else 0
11110        self.schema = schema if schema is not None else ''
11111        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11112        '''
11113         ID of the secret store containing credentials for this resource, if any.
11114        '''
11115        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11116        '''
11117         Tags is a map of key, value pairs.
11118        '''
11119        self.username = username if username is not None else ''
11120
11121    def __repr__(self):
11122        return '<sdm.Snowflake ' + \
11123            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11124            'database: ' + repr(self.database) + ' ' +\
11125            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11126            'healthy: ' + repr(self.healthy) + ' ' +\
11127            'hostname: ' + repr(self.hostname) + ' ' +\
11128            'id: ' + repr(self.id) + ' ' +\
11129            'name: ' + repr(self.name) + ' ' +\
11130            'password: ' + repr(self.password) + ' ' +\
11131            'port_override: ' + repr(self.port_override) + ' ' +\
11132            'schema: ' + repr(self.schema) + ' ' +\
11133            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11134            'tags: ' + repr(self.tags) + ' ' +\
11135            'username: ' + repr(self.username) + ' ' +\
11136            '>'
11137
11138    def to_dict(self):
11139        return {
11140            'bind_interface': self.bind_interface,
11141            'database': self.database,
11142            'egress_filter': self.egress_filter,
11143            'healthy': self.healthy,
11144            'hostname': self.hostname,
11145            'id': self.id,
11146            'name': self.name,
11147            'password': self.password,
11148            'port_override': self.port_override,
11149            'schema': self.schema,
11150            'secret_store_id': self.secret_store_id,
11151            'tags': self.tags,
11152            'username': self.username,
11153        }
11154
11155    @classmethod
11156    def from_dict(cls, d):
11157        return cls(
11158            bind_interface=d.get('bind_interface'),
11159            database=d.get('database'),
11160            egress_filter=d.get('egress_filter'),
11161            healthy=d.get('healthy'),
11162            hostname=d.get('hostname'),
11163            id=d.get('id'),
11164            name=d.get('name'),
11165            password=d.get('password'),
11166            port_override=d.get('port_override'),
11167            schema=d.get('schema'),
11168            secret_store_id=d.get('secret_store_id'),
11169            tags=d.get('tags'),
11170            username=d.get('username'),
11171        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11070    def __init__(
11071        self,
11072        bind_interface=None,
11073        database=None,
11074        egress_filter=None,
11075        healthy=None,
11076        hostname=None,
11077        id=None,
11078        name=None,
11079        password=None,
11080        port_override=None,
11081        schema=None,
11082        secret_store_id=None,
11083        tags=None,
11084        username=None,
11085    ):
11086        self.bind_interface = bind_interface if bind_interface is not None else ''
11087        '''
11088         Bind interface
11089        '''
11090        self.database = database if database is not None else ''
11091        self.egress_filter = egress_filter if egress_filter is not None else ''
11092        '''
11093         A filter applied to the routing logic to pin datasource to nodes.
11094        '''
11095        self.healthy = healthy if healthy is not None else False
11096        '''
11097         True if the datasource is reachable and the credentials are valid.
11098        '''
11099        self.hostname = hostname if hostname is not None else ''
11100        self.id = id if id is not None else ''
11101        '''
11102         Unique identifier of the Resource.
11103        '''
11104        self.name = name if name is not None else ''
11105        '''
11106         Unique human-readable name of the Resource.
11107        '''
11108        self.password = password if password is not None else ''
11109        self.port_override = port_override if port_override is not None else 0
11110        self.schema = schema if schema is not None else ''
11111        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11112        '''
11113         ID of the secret store containing credentials for this resource, if any.
11114        '''
11115        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11116        '''
11117         Tags is a map of key, value pairs.
11118        '''
11119        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11138    def to_dict(self):
11139        return {
11140            'bind_interface': self.bind_interface,
11141            'database': self.database,
11142            'egress_filter': self.egress_filter,
11143            'healthy': self.healthy,
11144            'hostname': self.hostname,
11145            'id': self.id,
11146            'name': self.name,
11147            'password': self.password,
11148            'port_override': self.port_override,
11149            'schema': self.schema,
11150            'secret_store_id': self.secret_store_id,
11151            'tags': self.tags,
11152            'username': self.username,
11153        }
@classmethod
def from_dict(cls, d)
11155    @classmethod
11156    def from_dict(cls, d):
11157        return cls(
11158            bind_interface=d.get('bind_interface'),
11159            database=d.get('database'),
11160            egress_filter=d.get('egress_filter'),
11161            healthy=d.get('healthy'),
11162            hostname=d.get('hostname'),
11163            id=d.get('id'),
11164            name=d.get('name'),
11165            password=d.get('password'),
11166            port_override=d.get('port_override'),
11167            schema=d.get('schema'),
11168            secret_store_id=d.get('secret_store_id'),
11169            tags=d.get('tags'),
11170            username=d.get('username'),
11171        )
class Sybase:
11174class Sybase:
11175    __slots__ = [
11176        'bind_interface',
11177        'egress_filter',
11178        'healthy',
11179        'hostname',
11180        'id',
11181        'name',
11182        'password',
11183        'port',
11184        'port_override',
11185        'secret_store_id',
11186        'tags',
11187        'username',
11188    ]
11189
11190    def __init__(
11191        self,
11192        bind_interface=None,
11193        egress_filter=None,
11194        healthy=None,
11195        hostname=None,
11196        id=None,
11197        name=None,
11198        password=None,
11199        port=None,
11200        port_override=None,
11201        secret_store_id=None,
11202        tags=None,
11203        username=None,
11204    ):
11205        self.bind_interface = bind_interface if bind_interface is not None else ''
11206        '''
11207         Bind interface
11208        '''
11209        self.egress_filter = egress_filter if egress_filter is not None else ''
11210        '''
11211         A filter applied to the routing logic to pin datasource to nodes.
11212        '''
11213        self.healthy = healthy if healthy is not None else False
11214        '''
11215         True if the datasource is reachable and the credentials are valid.
11216        '''
11217        self.hostname = hostname if hostname is not None else ''
11218        self.id = id if id is not None else ''
11219        '''
11220         Unique identifier of the Resource.
11221        '''
11222        self.name = name if name is not None else ''
11223        '''
11224         Unique human-readable name of the Resource.
11225        '''
11226        self.password = password if password is not None else ''
11227        self.port = port if port is not None else 0
11228        self.port_override = port_override if port_override is not None else 0
11229        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11230        '''
11231         ID of the secret store containing credentials for this resource, if any.
11232        '''
11233        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11234        '''
11235         Tags is a map of key, value pairs.
11236        '''
11237        self.username = username if username is not None else ''
11238
11239    def __repr__(self):
11240        return '<sdm.Sybase ' + \
11241            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11242            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11243            'healthy: ' + repr(self.healthy) + ' ' +\
11244            'hostname: ' + repr(self.hostname) + ' ' +\
11245            'id: ' + repr(self.id) + ' ' +\
11246            'name: ' + repr(self.name) + ' ' +\
11247            'password: ' + repr(self.password) + ' ' +\
11248            'port: ' + repr(self.port) + ' ' +\
11249            'port_override: ' + repr(self.port_override) + ' ' +\
11250            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11251            'tags: ' + repr(self.tags) + ' ' +\
11252            'username: ' + repr(self.username) + ' ' +\
11253            '>'
11254
11255    def to_dict(self):
11256        return {
11257            'bind_interface': self.bind_interface,
11258            'egress_filter': self.egress_filter,
11259            'healthy': self.healthy,
11260            'hostname': self.hostname,
11261            'id': self.id,
11262            'name': self.name,
11263            'password': self.password,
11264            'port': self.port,
11265            'port_override': self.port_override,
11266            'secret_store_id': self.secret_store_id,
11267            'tags': self.tags,
11268            'username': self.username,
11269        }
11270
11271    @classmethod
11272    def from_dict(cls, d):
11273        return cls(
11274            bind_interface=d.get('bind_interface'),
11275            egress_filter=d.get('egress_filter'),
11276            healthy=d.get('healthy'),
11277            hostname=d.get('hostname'),
11278            id=d.get('id'),
11279            name=d.get('name'),
11280            password=d.get('password'),
11281            port=d.get('port'),
11282            port_override=d.get('port_override'),
11283            secret_store_id=d.get('secret_store_id'),
11284            tags=d.get('tags'),
11285            username=d.get('username'),
11286        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11190    def __init__(
11191        self,
11192        bind_interface=None,
11193        egress_filter=None,
11194        healthy=None,
11195        hostname=None,
11196        id=None,
11197        name=None,
11198        password=None,
11199        port=None,
11200        port_override=None,
11201        secret_store_id=None,
11202        tags=None,
11203        username=None,
11204    ):
11205        self.bind_interface = bind_interface if bind_interface is not None else ''
11206        '''
11207         Bind interface
11208        '''
11209        self.egress_filter = egress_filter if egress_filter is not None else ''
11210        '''
11211         A filter applied to the routing logic to pin datasource to nodes.
11212        '''
11213        self.healthy = healthy if healthy is not None else False
11214        '''
11215         True if the datasource is reachable and the credentials are valid.
11216        '''
11217        self.hostname = hostname if hostname is not None else ''
11218        self.id = id if id is not None else ''
11219        '''
11220         Unique identifier of the Resource.
11221        '''
11222        self.name = name if name is not None else ''
11223        '''
11224         Unique human-readable name of the Resource.
11225        '''
11226        self.password = password if password is not None else ''
11227        self.port = port if port is not None else 0
11228        self.port_override = port_override if port_override is not None else 0
11229        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11230        '''
11231         ID of the secret store containing credentials for this resource, if any.
11232        '''
11233        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11234        '''
11235         Tags is a map of key, value pairs.
11236        '''
11237        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11255    def to_dict(self):
11256        return {
11257            'bind_interface': self.bind_interface,
11258            'egress_filter': self.egress_filter,
11259            'healthy': self.healthy,
11260            'hostname': self.hostname,
11261            'id': self.id,
11262            'name': self.name,
11263            'password': self.password,
11264            'port': self.port,
11265            'port_override': self.port_override,
11266            'secret_store_id': self.secret_store_id,
11267            'tags': self.tags,
11268            'username': self.username,
11269        }
@classmethod
def from_dict(cls, d)
11271    @classmethod
11272    def from_dict(cls, d):
11273        return cls(
11274            bind_interface=d.get('bind_interface'),
11275            egress_filter=d.get('egress_filter'),
11276            healthy=d.get('healthy'),
11277            hostname=d.get('hostname'),
11278            id=d.get('id'),
11279            name=d.get('name'),
11280            password=d.get('password'),
11281            port=d.get('port'),
11282            port_override=d.get('port_override'),
11283            secret_store_id=d.get('secret_store_id'),
11284            tags=d.get('tags'),
11285            username=d.get('username'),
11286        )
class SybaseIQ:
11289class SybaseIQ:
11290    __slots__ = [
11291        'bind_interface',
11292        'egress_filter',
11293        'healthy',
11294        'hostname',
11295        'id',
11296        'name',
11297        'password',
11298        'port',
11299        'port_override',
11300        'secret_store_id',
11301        'tags',
11302        'username',
11303    ]
11304
11305    def __init__(
11306        self,
11307        bind_interface=None,
11308        egress_filter=None,
11309        healthy=None,
11310        hostname=None,
11311        id=None,
11312        name=None,
11313        password=None,
11314        port=None,
11315        port_override=None,
11316        secret_store_id=None,
11317        tags=None,
11318        username=None,
11319    ):
11320        self.bind_interface = bind_interface if bind_interface is not None else ''
11321        '''
11322         Bind interface
11323        '''
11324        self.egress_filter = egress_filter if egress_filter is not None else ''
11325        '''
11326         A filter applied to the routing logic to pin datasource to nodes.
11327        '''
11328        self.healthy = healthy if healthy is not None else False
11329        '''
11330         True if the datasource is reachable and the credentials are valid.
11331        '''
11332        self.hostname = hostname if hostname is not None else ''
11333        self.id = id if id is not None else ''
11334        '''
11335         Unique identifier of the Resource.
11336        '''
11337        self.name = name if name is not None else ''
11338        '''
11339         Unique human-readable name of the Resource.
11340        '''
11341        self.password = password if password is not None else ''
11342        self.port = port if port is not None else 0
11343        self.port_override = port_override if port_override is not None else 0
11344        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11345        '''
11346         ID of the secret store containing credentials for this resource, if any.
11347        '''
11348        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11349        '''
11350         Tags is a map of key, value pairs.
11351        '''
11352        self.username = username if username is not None else ''
11353
11354    def __repr__(self):
11355        return '<sdm.SybaseIQ ' + \
11356            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11357            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11358            'healthy: ' + repr(self.healthy) + ' ' +\
11359            'hostname: ' + repr(self.hostname) + ' ' +\
11360            'id: ' + repr(self.id) + ' ' +\
11361            'name: ' + repr(self.name) + ' ' +\
11362            'password: ' + repr(self.password) + ' ' +\
11363            'port: ' + repr(self.port) + ' ' +\
11364            'port_override: ' + repr(self.port_override) + ' ' +\
11365            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11366            'tags: ' + repr(self.tags) + ' ' +\
11367            'username: ' + repr(self.username) + ' ' +\
11368            '>'
11369
11370    def to_dict(self):
11371        return {
11372            'bind_interface': self.bind_interface,
11373            'egress_filter': self.egress_filter,
11374            'healthy': self.healthy,
11375            'hostname': self.hostname,
11376            'id': self.id,
11377            'name': self.name,
11378            'password': self.password,
11379            'port': self.port,
11380            'port_override': self.port_override,
11381            'secret_store_id': self.secret_store_id,
11382            'tags': self.tags,
11383            'username': self.username,
11384        }
11385
11386    @classmethod
11387    def from_dict(cls, d):
11388        return cls(
11389            bind_interface=d.get('bind_interface'),
11390            egress_filter=d.get('egress_filter'),
11391            healthy=d.get('healthy'),
11392            hostname=d.get('hostname'),
11393            id=d.get('id'),
11394            name=d.get('name'),
11395            password=d.get('password'),
11396            port=d.get('port'),
11397            port_override=d.get('port_override'),
11398            secret_store_id=d.get('secret_store_id'),
11399            tags=d.get('tags'),
11400            username=d.get('username'),
11401        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11305    def __init__(
11306        self,
11307        bind_interface=None,
11308        egress_filter=None,
11309        healthy=None,
11310        hostname=None,
11311        id=None,
11312        name=None,
11313        password=None,
11314        port=None,
11315        port_override=None,
11316        secret_store_id=None,
11317        tags=None,
11318        username=None,
11319    ):
11320        self.bind_interface = bind_interface if bind_interface is not None else ''
11321        '''
11322         Bind interface
11323        '''
11324        self.egress_filter = egress_filter if egress_filter is not None else ''
11325        '''
11326         A filter applied to the routing logic to pin datasource to nodes.
11327        '''
11328        self.healthy = healthy if healthy is not None else False
11329        '''
11330         True if the datasource is reachable and the credentials are valid.
11331        '''
11332        self.hostname = hostname if hostname is not None else ''
11333        self.id = id if id is not None else ''
11334        '''
11335         Unique identifier of the Resource.
11336        '''
11337        self.name = name if name is not None else ''
11338        '''
11339         Unique human-readable name of the Resource.
11340        '''
11341        self.password = password if password is not None else ''
11342        self.port = port if port is not None else 0
11343        self.port_override = port_override if port_override is not None else 0
11344        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11345        '''
11346         ID of the secret store containing credentials for this resource, if any.
11347        '''
11348        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11349        '''
11350         Tags is a map of key, value pairs.
11351        '''
11352        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11370    def to_dict(self):
11371        return {
11372            'bind_interface': self.bind_interface,
11373            'egress_filter': self.egress_filter,
11374            'healthy': self.healthy,
11375            'hostname': self.hostname,
11376            'id': self.id,
11377            'name': self.name,
11378            'password': self.password,
11379            'port': self.port,
11380            'port_override': self.port_override,
11381            'secret_store_id': self.secret_store_id,
11382            'tags': self.tags,
11383            'username': self.username,
11384        }
@classmethod
def from_dict(cls, d)
11386    @classmethod
11387    def from_dict(cls, d):
11388        return cls(
11389            bind_interface=d.get('bind_interface'),
11390            egress_filter=d.get('egress_filter'),
11391            healthy=d.get('healthy'),
11392            hostname=d.get('hostname'),
11393            id=d.get('id'),
11394            name=d.get('name'),
11395            password=d.get('password'),
11396            port=d.get('port'),
11397            port_override=d.get('port_override'),
11398            secret_store_id=d.get('secret_store_id'),
11399            tags=d.get('tags'),
11400            username=d.get('username'),
11401        )
class Tag:
11404class Tag:
11405    __slots__ = [
11406        'name',
11407        'value',
11408    ]
11409
11410    def __init__(
11411        self,
11412        name=None,
11413        value=None,
11414    ):
11415        self.name = name if name is not None else ''
11416        self.value = value if value is not None else ''
11417
11418    def __repr__(self):
11419        return '<sdm.Tag ' + \
11420            'name: ' + repr(self.name) + ' ' +\
11421            'value: ' + repr(self.value) + ' ' +\
11422            '>'
11423
11424    def to_dict(self):
11425        return {
11426            'name': self.name,
11427            'value': self.value,
11428        }
11429
11430    @classmethod
11431    def from_dict(cls, d):
11432        return cls(
11433            name=d.get('name'),
11434            value=d.get('value'),
11435        )
Tag(name=None, value=None)
11410    def __init__(
11411        self,
11412        name=None,
11413        value=None,
11414    ):
11415        self.name = name if name is not None else ''
11416        self.value = value if value is not None else ''
name
value
def to_dict(self)
11424    def to_dict(self):
11425        return {
11426            'name': self.name,
11427            'value': self.value,
11428        }
@classmethod
def from_dict(cls, d)
11430    @classmethod
11431    def from_dict(cls, d):
11432        return cls(
11433            name=d.get('name'),
11434            value=d.get('value'),
11435        )
class Teradata:
11438class Teradata:
11439    __slots__ = [
11440        'bind_interface',
11441        'egress_filter',
11442        'healthy',
11443        'hostname',
11444        'id',
11445        'name',
11446        'password',
11447        'port',
11448        'port_override',
11449        'secret_store_id',
11450        'tags',
11451        'username',
11452    ]
11453
11454    def __init__(
11455        self,
11456        bind_interface=None,
11457        egress_filter=None,
11458        healthy=None,
11459        hostname=None,
11460        id=None,
11461        name=None,
11462        password=None,
11463        port=None,
11464        port_override=None,
11465        secret_store_id=None,
11466        tags=None,
11467        username=None,
11468    ):
11469        self.bind_interface = bind_interface if bind_interface is not None else ''
11470        '''
11471         Bind interface
11472        '''
11473        self.egress_filter = egress_filter if egress_filter is not None else ''
11474        '''
11475         A filter applied to the routing logic to pin datasource to nodes.
11476        '''
11477        self.healthy = healthy if healthy is not None else False
11478        '''
11479         True if the datasource is reachable and the credentials are valid.
11480        '''
11481        self.hostname = hostname if hostname is not None else ''
11482        self.id = id if id is not None else ''
11483        '''
11484         Unique identifier of the Resource.
11485        '''
11486        self.name = name if name is not None else ''
11487        '''
11488         Unique human-readable name of the Resource.
11489        '''
11490        self.password = password if password is not None else ''
11491        self.port = port if port is not None else 0
11492        self.port_override = port_override if port_override is not None else 0
11493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11494        '''
11495         ID of the secret store containing credentials for this resource, if any.
11496        '''
11497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11498        '''
11499         Tags is a map of key, value pairs.
11500        '''
11501        self.username = username if username is not None else ''
11502
11503    def __repr__(self):
11504        return '<sdm.Teradata ' + \
11505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11507            'healthy: ' + repr(self.healthy) + ' ' +\
11508            'hostname: ' + repr(self.hostname) + ' ' +\
11509            'id: ' + repr(self.id) + ' ' +\
11510            'name: ' + repr(self.name) + ' ' +\
11511            'password: ' + repr(self.password) + ' ' +\
11512            'port: ' + repr(self.port) + ' ' +\
11513            'port_override: ' + repr(self.port_override) + ' ' +\
11514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11515            'tags: ' + repr(self.tags) + ' ' +\
11516            'username: ' + repr(self.username) + ' ' +\
11517            '>'
11518
11519    def to_dict(self):
11520        return {
11521            'bind_interface': self.bind_interface,
11522            'egress_filter': self.egress_filter,
11523            'healthy': self.healthy,
11524            'hostname': self.hostname,
11525            'id': self.id,
11526            'name': self.name,
11527            'password': self.password,
11528            'port': self.port,
11529            'port_override': self.port_override,
11530            'secret_store_id': self.secret_store_id,
11531            'tags': self.tags,
11532            'username': self.username,
11533        }
11534
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            bind_interface=d.get('bind_interface'),
11539            egress_filter=d.get('egress_filter'),
11540            healthy=d.get('healthy'),
11541            hostname=d.get('hostname'),
11542            id=d.get('id'),
11543            name=d.get('name'),
11544            password=d.get('password'),
11545            port=d.get('port'),
11546            port_override=d.get('port_override'),
11547            secret_store_id=d.get('secret_store_id'),
11548            tags=d.get('tags'),
11549            username=d.get('username'),
11550        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11454    def __init__(
11455        self,
11456        bind_interface=None,
11457        egress_filter=None,
11458        healthy=None,
11459        hostname=None,
11460        id=None,
11461        name=None,
11462        password=None,
11463        port=None,
11464        port_override=None,
11465        secret_store_id=None,
11466        tags=None,
11467        username=None,
11468    ):
11469        self.bind_interface = bind_interface if bind_interface is not None else ''
11470        '''
11471         Bind interface
11472        '''
11473        self.egress_filter = egress_filter if egress_filter is not None else ''
11474        '''
11475         A filter applied to the routing logic to pin datasource to nodes.
11476        '''
11477        self.healthy = healthy if healthy is not None else False
11478        '''
11479         True if the datasource is reachable and the credentials are valid.
11480        '''
11481        self.hostname = hostname if hostname is not None else ''
11482        self.id = id if id is not None else ''
11483        '''
11484         Unique identifier of the Resource.
11485        '''
11486        self.name = name if name is not None else ''
11487        '''
11488         Unique human-readable name of the Resource.
11489        '''
11490        self.password = password if password is not None else ''
11491        self.port = port if port is not None else 0
11492        self.port_override = port_override if port_override is not None else 0
11493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11494        '''
11495         ID of the secret store containing credentials for this resource, if any.
11496        '''
11497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11498        '''
11499         Tags is a map of key, value pairs.
11500        '''
11501        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11519    def to_dict(self):
11520        return {
11521            'bind_interface': self.bind_interface,
11522            'egress_filter': self.egress_filter,
11523            'healthy': self.healthy,
11524            'hostname': self.hostname,
11525            'id': self.id,
11526            'name': self.name,
11527            'password': self.password,
11528            'port': self.port,
11529            'port_override': self.port_override,
11530            'secret_store_id': self.secret_store_id,
11531            'tags': self.tags,
11532            'username': self.username,
11533        }
@classmethod
def from_dict(cls, d)
11535    @classmethod
11536    def from_dict(cls, d):
11537        return cls(
11538            bind_interface=d.get('bind_interface'),
11539            egress_filter=d.get('egress_filter'),
11540            healthy=d.get('healthy'),
11541            hostname=d.get('hostname'),
11542            id=d.get('id'),
11543            name=d.get('name'),
11544            password=d.get('password'),
11545            port=d.get('port'),
11546            port_override=d.get('port_override'),
11547            secret_store_id=d.get('secret_store_id'),
11548            tags=d.get('tags'),
11549            username=d.get('username'),
11550        )
class UpdateResponseMetadata:
11553class UpdateResponseMetadata:
11554    '''
11555         UpdateResponseMetadata is reserved for future use.
11556    '''
11557    __slots__ = []
11558
11559    def __init__(self, ):
11560        pass
11561
11562    def __repr__(self):
11563        return '<sdm.UpdateResponseMetadata ' + \
11564            '>'
11565
11566    def to_dict(self):
11567        return {}
11568
11569    @classmethod
11570    def from_dict(cls, d):
11571        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
11559    def __init__(self, ):
11560        pass
def to_dict(self)
11566    def to_dict(self):
11567        return {}
@classmethod
def from_dict(cls, d)
11569    @classmethod
11570    def from_dict(cls, d):
11571        return cls()
class User:
11574class User:
11575    '''
11576         A User can connect to resources they are granted directly, or granted
11577     via roles.
11578    '''
11579    __slots__ = [
11580        'email',
11581        'first_name',
11582        'id',
11583        'last_name',
11584        'suspended',
11585        'tags',
11586    ]
11587
11588    def __init__(
11589        self,
11590        email=None,
11591        first_name=None,
11592        id=None,
11593        last_name=None,
11594        suspended=None,
11595        tags=None,
11596    ):
11597        self.email = email if email is not None else ''
11598        '''
11599         The User's email address. Must be unique.
11600        '''
11601        self.first_name = first_name if first_name is not None else ''
11602        '''
11603         The User's first name.
11604        '''
11605        self.id = id if id is not None else ''
11606        '''
11607         Unique identifier of the User.
11608        '''
11609        self.last_name = last_name if last_name is not None else ''
11610        '''
11611         The User's last name.
11612        '''
11613        self.suspended = suspended if suspended is not None else False
11614        '''
11615         The User's suspended state.
11616        '''
11617        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11618        '''
11619         Tags is a map of key, value pairs.
11620        '''
11621
11622    def __repr__(self):
11623        return '<sdm.User ' + \
11624            'email: ' + repr(self.email) + ' ' +\
11625            'first_name: ' + repr(self.first_name) + ' ' +\
11626            'id: ' + repr(self.id) + ' ' +\
11627            'last_name: ' + repr(self.last_name) + ' ' +\
11628            'suspended: ' + repr(self.suspended) + ' ' +\
11629            'tags: ' + repr(self.tags) + ' ' +\
11630            '>'
11631
11632    def to_dict(self):
11633        return {
11634            'email': self.email,
11635            'first_name': self.first_name,
11636            'id': self.id,
11637            'last_name': self.last_name,
11638            'suspended': self.suspended,
11639            'tags': self.tags,
11640        }
11641
11642    @classmethod
11643    def from_dict(cls, d):
11644        return cls(
11645            email=d.get('email'),
11646            first_name=d.get('first_name'),
11647            id=d.get('id'),
11648            last_name=d.get('last_name'),
11649            suspended=d.get('suspended'),
11650            tags=d.get('tags'),
11651        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
11588    def __init__(
11589        self,
11590        email=None,
11591        first_name=None,
11592        id=None,
11593        last_name=None,
11594        suspended=None,
11595        tags=None,
11596    ):
11597        self.email = email if email is not None else ''
11598        '''
11599         The User's email address. Must be unique.
11600        '''
11601        self.first_name = first_name if first_name is not None else ''
11602        '''
11603         The User's first name.
11604        '''
11605        self.id = id if id is not None else ''
11606        '''
11607         Unique identifier of the User.
11608        '''
11609        self.last_name = last_name if last_name is not None else ''
11610        '''
11611         The User's last name.
11612        '''
11613        self.suspended = suspended if suspended is not None else False
11614        '''
11615         The User's suspended state.
11616        '''
11617        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11618        '''
11619         Tags is a map of key, value pairs.
11620        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11632    def to_dict(self):
11633        return {
11634            'email': self.email,
11635            'first_name': self.first_name,
11636            'id': self.id,
11637            'last_name': self.last_name,
11638            'suspended': self.suspended,
11639            'tags': self.tags,
11640        }
@classmethod
def from_dict(cls, d)
11642    @classmethod
11643    def from_dict(cls, d):
11644        return cls(
11645            email=d.get('email'),
11646            first_name=d.get('first_name'),
11647            id=d.get('id'),
11648            last_name=d.get('last_name'),
11649            suspended=d.get('suspended'),
11650            tags=d.get('tags'),
11651        )
class VaultAppRoleStore:
11654class VaultAppRoleStore:
11655    __slots__ = [
11656        'id',
11657        'name',
11658        'namespace',
11659        'server_address',
11660        'tags',
11661    ]
11662
11663    def __init__(
11664        self,
11665        id=None,
11666        name=None,
11667        namespace=None,
11668        server_address=None,
11669        tags=None,
11670    ):
11671        self.id = id if id is not None else ''
11672        '''
11673         Unique identifier of the SecretStore.
11674        '''
11675        self.name = name if name is not None else ''
11676        '''
11677         Unique human-readable name of the SecretStore.
11678        '''
11679        self.namespace = namespace if namespace is not None else ''
11680        self.server_address = server_address if server_address is not None else ''
11681        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11682        '''
11683         Tags is a map of key, value pairs.
11684        '''
11685
11686    def __repr__(self):
11687        return '<sdm.VaultAppRoleStore ' + \
11688            'id: ' + repr(self.id) + ' ' +\
11689            'name: ' + repr(self.name) + ' ' +\
11690            'namespace: ' + repr(self.namespace) + ' ' +\
11691            'server_address: ' + repr(self.server_address) + ' ' +\
11692            'tags: ' + repr(self.tags) + ' ' +\
11693            '>'
11694
11695    def to_dict(self):
11696        return {
11697            'id': self.id,
11698            'name': self.name,
11699            'namespace': self.namespace,
11700            'server_address': self.server_address,
11701            'tags': self.tags,
11702        }
11703
11704    @classmethod
11705    def from_dict(cls, d):
11706        return cls(
11707            id=d.get('id'),
11708            name=d.get('name'),
11709            namespace=d.get('namespace'),
11710            server_address=d.get('server_address'),
11711            tags=d.get('tags'),
11712        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
11663    def __init__(
11664        self,
11665        id=None,
11666        name=None,
11667        namespace=None,
11668        server_address=None,
11669        tags=None,
11670    ):
11671        self.id = id if id is not None else ''
11672        '''
11673         Unique identifier of the SecretStore.
11674        '''
11675        self.name = name if name is not None else ''
11676        '''
11677         Unique human-readable name of the SecretStore.
11678        '''
11679        self.namespace = namespace if namespace is not None else ''
11680        self.server_address = server_address if server_address is not None else ''
11681        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11682        '''
11683         Tags is a map of key, value pairs.
11684        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11695    def to_dict(self):
11696        return {
11697            'id': self.id,
11698            'name': self.name,
11699            'namespace': self.namespace,
11700            'server_address': self.server_address,
11701            'tags': self.tags,
11702        }
@classmethod
def from_dict(cls, d)
11704    @classmethod
11705    def from_dict(cls, d):
11706        return cls(
11707            id=d.get('id'),
11708            name=d.get('name'),
11709            namespace=d.get('namespace'),
11710            server_address=d.get('server_address'),
11711            tags=d.get('tags'),
11712        )
class VaultTLSStore:
11715class VaultTLSStore:
11716    __slots__ = [
11717        'ca_cert_path',
11718        'client_cert_path',
11719        'client_key_path',
11720        'id',
11721        'name',
11722        'namespace',
11723        'server_address',
11724        'tags',
11725    ]
11726
11727    def __init__(
11728        self,
11729        ca_cert_path=None,
11730        client_cert_path=None,
11731        client_key_path=None,
11732        id=None,
11733        name=None,
11734        namespace=None,
11735        server_address=None,
11736        tags=None,
11737    ):
11738        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11739        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11740        self.client_key_path = client_key_path if client_key_path is not None else ''
11741        self.id = id if id is not None else ''
11742        '''
11743         Unique identifier of the SecretStore.
11744        '''
11745        self.name = name if name is not None else ''
11746        '''
11747         Unique human-readable name of the SecretStore.
11748        '''
11749        self.namespace = namespace if namespace is not None else ''
11750        self.server_address = server_address if server_address is not None else ''
11751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11752        '''
11753         Tags is a map of key, value pairs.
11754        '''
11755
11756    def __repr__(self):
11757        return '<sdm.VaultTLSStore ' + \
11758            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
11759            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
11760            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
11761            'id: ' + repr(self.id) + ' ' +\
11762            'name: ' + repr(self.name) + ' ' +\
11763            'namespace: ' + repr(self.namespace) + ' ' +\
11764            'server_address: ' + repr(self.server_address) + ' ' +\
11765            'tags: ' + repr(self.tags) + ' ' +\
11766            '>'
11767
11768    def to_dict(self):
11769        return {
11770            'ca_cert_path': self.ca_cert_path,
11771            'client_cert_path': self.client_cert_path,
11772            'client_key_path': self.client_key_path,
11773            'id': self.id,
11774            'name': self.name,
11775            'namespace': self.namespace,
11776            'server_address': self.server_address,
11777            'tags': self.tags,
11778        }
11779
11780    @classmethod
11781    def from_dict(cls, d):
11782        return cls(
11783            ca_cert_path=d.get('ca_cert_path'),
11784            client_cert_path=d.get('client_cert_path'),
11785            client_key_path=d.get('client_key_path'),
11786            id=d.get('id'),
11787            name=d.get('name'),
11788            namespace=d.get('namespace'),
11789            server_address=d.get('server_address'),
11790            tags=d.get('tags'),
11791        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
11727    def __init__(
11728        self,
11729        ca_cert_path=None,
11730        client_cert_path=None,
11731        client_key_path=None,
11732        id=None,
11733        name=None,
11734        namespace=None,
11735        server_address=None,
11736        tags=None,
11737    ):
11738        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11739        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11740        self.client_key_path = client_key_path if client_key_path is not None else ''
11741        self.id = id if id is not None else ''
11742        '''
11743         Unique identifier of the SecretStore.
11744        '''
11745        self.name = name if name is not None else ''
11746        '''
11747         Unique human-readable name of the SecretStore.
11748        '''
11749        self.namespace = namespace if namespace is not None else ''
11750        self.server_address = server_address if server_address is not None else ''
11751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11752        '''
11753         Tags is a map of key, value pairs.
11754        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11768    def to_dict(self):
11769        return {
11770            'ca_cert_path': self.ca_cert_path,
11771            'client_cert_path': self.client_cert_path,
11772            'client_key_path': self.client_key_path,
11773            'id': self.id,
11774            'name': self.name,
11775            'namespace': self.namespace,
11776            'server_address': self.server_address,
11777            'tags': self.tags,
11778        }
@classmethod
def from_dict(cls, d)
11780    @classmethod
11781    def from_dict(cls, d):
11782        return cls(
11783            ca_cert_path=d.get('ca_cert_path'),
11784            client_cert_path=d.get('client_cert_path'),
11785            client_key_path=d.get('client_key_path'),
11786            id=d.get('id'),
11787            name=d.get('name'),
11788            namespace=d.get('namespace'),
11789            server_address=d.get('server_address'),
11790            tags=d.get('tags'),
11791        )
class VaultTokenStore:
11794class VaultTokenStore:
11795    __slots__ = [
11796        'id',
11797        'name',
11798        'namespace',
11799        'server_address',
11800        'tags',
11801    ]
11802
11803    def __init__(
11804        self,
11805        id=None,
11806        name=None,
11807        namespace=None,
11808        server_address=None,
11809        tags=None,
11810    ):
11811        self.id = id if id is not None else ''
11812        '''
11813         Unique identifier of the SecretStore.
11814        '''
11815        self.name = name if name is not None else ''
11816        '''
11817         Unique human-readable name of the SecretStore.
11818        '''
11819        self.namespace = namespace if namespace is not None else ''
11820        self.server_address = server_address if server_address is not None else ''
11821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11822        '''
11823         Tags is a map of key, value pairs.
11824        '''
11825
11826    def __repr__(self):
11827        return '<sdm.VaultTokenStore ' + \
11828            'id: ' + repr(self.id) + ' ' +\
11829            'name: ' + repr(self.name) + ' ' +\
11830            'namespace: ' + repr(self.namespace) + ' ' +\
11831            'server_address: ' + repr(self.server_address) + ' ' +\
11832            'tags: ' + repr(self.tags) + ' ' +\
11833            '>'
11834
11835    def to_dict(self):
11836        return {
11837            'id': self.id,
11838            'name': self.name,
11839            'namespace': self.namespace,
11840            'server_address': self.server_address,
11841            'tags': self.tags,
11842        }
11843
11844    @classmethod
11845    def from_dict(cls, d):
11846        return cls(
11847            id=d.get('id'),
11848            name=d.get('name'),
11849            namespace=d.get('namespace'),
11850            server_address=d.get('server_address'),
11851            tags=d.get('tags'),
11852        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
11803    def __init__(
11804        self,
11805        id=None,
11806        name=None,
11807        namespace=None,
11808        server_address=None,
11809        tags=None,
11810    ):
11811        self.id = id if id is not None else ''
11812        '''
11813         Unique identifier of the SecretStore.
11814        '''
11815        self.name = name if name is not None else ''
11816        '''
11817         Unique human-readable name of the SecretStore.
11818        '''
11819        self.namespace = namespace if namespace is not None else ''
11820        self.server_address = server_address if server_address is not None else ''
11821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11822        '''
11823         Tags is a map of key, value pairs.
11824        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11835    def to_dict(self):
11836        return {
11837            'id': self.id,
11838            'name': self.name,
11839            'namespace': self.namespace,
11840            'server_address': self.server_address,
11841            'tags': self.tags,
11842        }
@classmethod
def from_dict(cls, d)
11844    @classmethod
11845    def from_dict(cls, d):
11846        return cls(
11847            id=d.get('id'),
11848            name=d.get('name'),
11849            namespace=d.get('namespace'),
11850            server_address=d.get('server_address'),
11851            tags=d.get('tags'),
11852        )